Big rename from projects to repos with a project payload — radicle-explorer

👉 Preview 👉 Workflow runs 👉 Branch on GitHub

 import type {
   Blob,
   DiffResponse,
   Project,
   ProjectListQuery,
   Remote,
   Repo,
   RepoListQuery,
   Tree,
   TreeStats,
 } from "./lib/project.js";
 } from "./lib/repo.js";
 import type {
   Author,
   Config,
   SeedingPolicy,
   DefaultSeedingPolicy,
 } from "./lib/shared.js";
 import type { Comment, Embed, Reaction } from "./lib/project/comment.js";
 import type { Comment, Embed, Reaction } from "./lib/repo/comment.js";
 import type {
   Commit,
   CommitBlob,

   DiffContent,
   DiffFile,
   HunkLine,
 } from "./lib/project/commit.js";
 import type { Issue, IssueState } from "./lib/project/issue.js";
 } from "./lib/repo/commit.js";
 import type { Issue, IssueState } from "./lib/repo/issue.js";
 import type {
   LifecycleState,
   Merge,

   Review,
   Revision,
   Verdict,
 } from "./lib/project/patch.js";
 } from "./lib/repo/patch.js";
 import type { RequestOptions } from "./lib/fetcher.js";
 import type { ZodSchema } from "zod";
 import { z, array, literal, number, object, string, union } from "zod";
 import * as project from "./lib/project.js";
 import * as repo from "./lib/repo.js";
 import { Fetcher } from "./lib/fetcher.js";
 import {
   nodeConfigSchema,

 } from "./lib/shared.js";
 export type {
   Author,
   BaseUrl,
   Blob,
   ChangesetWithDiff,

   Merge,
   Patch,
   PatchState,
   Project,
   ProjectListQuery,
   Reaction,
   Remote,
   Repo,
   RepoListQuery,
   Review,
   Revision,
   SeedingPolicy,
   TreeStats,
   Tree,
   TreeStats,
   Verdict,
 };

   #fetcher: Fetcher;
   public baseUrl: BaseUrl;
   public project: project.Client;
   public repo: repo.Client;
   public constructor(baseUrl: BaseUrl) {
     this.baseUrl = baseUrl;
     this.#fetcher = new Fetcher(this.baseUrl);
     this.project = new project.Client(this.#fetcher);
     this.repo = new repo.Client(this.#fetcher);
   }
   public changePort(port: number): void {

     );
   }
   public async getPolicyById(
     id: string,
   public async getPolicyByRid(
     rid: string,
     options?: RequestOptions,
   ): Promise<SeedingPolicy> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `node/policies/repos/${id}`,
         path: `node/policies/repos/${rid}`,
         options,
       },
       seedingPolicySchema,

   }
   public async getNodeIdentity(
     id: string,
     nid: string,
     options?: RequestOptions,
   ): Promise<NodeIdentity> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `nodes/${id}`,
         path: `nodes/${nid}`,
         options,
       },
       nodeIdentitySchema,

 import type { ZodSchema } from "zod";
 import type { Fetcher, RequestOptions } from "./fetcher.js";
 import type { Commit, Commits } from "./project/commit.js";
 import type { Issue } from "./project/issue.js";
 import type { Patch } from "./project/patch.js";
 import {
   array,
   boolean,
   literal,
   number,
   object,
   optional,
   record,
   string,
   union,
   z,
 } from "zod";
 import {
   commitHeaderSchema,
   commitSchema,
   commitsSchema,
   diffBlobSchema,
   diffSchema,
 } from "./project/commit.js";
 import { issueSchema, issuesSchema } from "./project/issue.js";
 import { patchSchema, patchesSchema } from "./project/patch.js";
 const projectSchema = object({
   id: string(),
   name: string(),
   description: string(),
   defaultBranch: string(),
   delegates: array(object({ id: string(), alias: optional(string()) })),
   head: string(),
   threshold: number(),
   visibility: union([
     object({ type: literal("public") }),
     object({ type: literal("private"), allow: optional(array(string())) }),
   ]).optional(),
   patches: object({
     open: number(),
     draft: number(),
     archived: number(),
     merged: number(),
   }),
   issues: object({
     open: number(),
     closed: number(),
   }),
   seeding: number(),
 });
 const projectsSchema = array(projectSchema);
 export type Project = z.infer<typeof projectSchema>;
 const activitySchema = object({
   activity: array(number()),
 });
 export type Activity = z.infer<typeof activitySchema>;
 const blobSchema = object({
   binary: boolean(),
   content: optional(string()),
   name: string(),
   path: string(),
   lastCommit: commitHeaderSchema,
 });
 export type Blob = z.infer<typeof blobSchema>;
 const treeEntrySchema = object({
   path: string(),
   name: string(),
   oid: string(),
   kind: union([literal("blob"), literal("tree"), literal("submodule")]),
 });
 export type TreeEntry = z.infer<typeof treeEntrySchema>;
 const treeStatsSchema = object({
   commits: number(),
   branches: number(),
   contributors: number(),
 });
 export type TreeStats = z.infer<typeof treeStatsSchema>;
 export type Tree = z.infer<typeof treeSchema>;
 const treeSchema = object({
   entries: array(treeEntrySchema),
   lastCommit: commitHeaderSchema,
   name: string(),
   path: string(),
 });
 export type Remote = z.infer<typeof remoteSchema>;
 export const remoteSchema = object({
   id: string(),
   alias: string().optional(),
   heads: record(string(), string()),
   delegate: boolean(),
 });
 const remotesSchema = array(remoteSchema) satisfies ZodSchema<Remote[]>;
 export type DiffResponse = z.infer<typeof diffResponseSchema>;
 const diffResponseSchema = object({
   commits: array(commitHeaderSchema),
   diff: diffSchema,
   files: record(string(), diffBlobSchema),
 });
 export type ProjectListQuery = {
   page?: number;
   perPage?: number;
   show?: "pinned" | "all";
 };
 export class Client {
   #fetcher: Fetcher;
   public constructor(fetcher: Fetcher) {
     this.#fetcher = fetcher;
   }
   public async getByDelegate(
     delegateId: string,
     query?: ProjectListQuery,
     options?: RequestOptions,
   ): Promise<Project[]> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `delegates/${delegateId}/projects`,
         query,
         options,
       },
       projectsSchema,
     );
   }
   public async getById(id: string, options?: RequestOptions): Promise<Project> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}`,
         options,
       },
       projectSchema,
     );
   }
   public async getAll(
     query?: ProjectListQuery,
     options?: RequestOptions,
   ): Promise<Project[]> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: "projects",
         query,
         options,
       },
       projectsSchema,
     );
   }
   public async getActivity(
     id: string,
     options?: RequestOptions,
   ): Promise<Activity> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/activity`,
         options,
       },
       activitySchema,
     );
   }
   public async getReadme(
     id: string,
     sha: string,
     options?: RequestOptions,
   ): Promise<Blob> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/readme/${sha}`,
         options,
       },
       blobSchema,
     );
   }
   public async getBlob(
     id: string,
     sha: string,
     path: string,
     options?: RequestOptions,
   ): Promise<Blob> {
     const blob = await this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/blob/${sha}/${path}`,
         options,
       },
       blobSchema,
     );
     return blob;
   }
   public async getTree(
     id: string,
     sha: string,
     path?: string,
     options?: RequestOptions,
   ): Promise<Tree> {
     const tree = await this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/tree/${sha}/${path ?? ""}`,
         options,
       },
       treeSchema,
     );
     return tree;
   }
   public async getTreeStatsBySha(
     id: string,
     sha: string,
     options?: RequestOptions,
   ): Promise<TreeStats> {
     const tree = await this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/stats/tree/${sha}`,
         options,
       },
       treeStatsSchema,
     );
     return tree;
   }
   public async getAllRemotes(
     id: string,
     options?: RequestOptions,
   ): Promise<Remote[]> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/remotes`,
         options,
       },
       remotesSchema,
     );
   }
   public async getRemoteByPeer(
     id: string,
     peer: string,
     options?: RequestOptions,
   ): Promise<Remote> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/remotes/${peer}`,
         options,
       },
       remoteSchema,
     );
   }
   public async getAllCommits(
     id: string,
     query?: {
       parent?: string;
       since?: number;
       until?: number;
       page?: number;
       perPage?: number;
     },
     options?: RequestOptions,
   ): Promise<Commits> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/commits`,
         query,
         options,
       },
       commitsSchema,
     );
   }
   public async getCommitBySha(
     id: string,
     sha: string,
     options?: RequestOptions,
   ): Promise<Commit> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/commits/${sha}`,
         options,
       },
       commitSchema,
     );
   }
   public async getDiff(
     id: string,
     revisionBase: string,
     revisionOid: string,
     options?: RequestOptions,
   ): Promise<DiffResponse> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/diff/${revisionBase}/${revisionOid}`,
         options,
       },
       diffResponseSchema,
     );
   }
   public async getIssueById(
     id: string,
     issueId: string,
     options?: RequestOptions,
   ): Promise<Issue> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/issues/${issueId}`,
         options,
       },
       issueSchema,
     );
   }
   public async getAllIssues(
     id: string,
     query?: {
       page?: number;
       perPage?: number;
       status?: string;
     },
     options?: RequestOptions,
   ): Promise<Issue[]> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/issues`,
         query,
         options,
       },
       issuesSchema,
     );
   }
   public async getPatchById(
     id: string,
     patchId: string,
     options?: RequestOptions,
   ): Promise<Patch> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/patches/${patchId}`,
         options,
       },
       patchSchema,
     );
   }
   public async getAllPatches(
     id: string,
     query?: {
       page?: number;
       perPage?: number;
       status?: string;
     },
     options?: RequestOptions,
   ): Promise<Patch[]> {
     return this.#fetcher.fetchOk(
       {
         method: "GET",
         path: `projects/${id}/patches`,
         query,
         options,
       },
       patchesSchema,
     );
   }
 }

 import type { z } from "zod";
 import { array, boolean, number, object, string } from "zod";
 import { authorSchema, codeLocationSchema } from "../shared";
 export type Comment = z.infer<typeof commentSchema>;
 export type Embed = Comment["embeds"][0];
 export type Reaction = Comment["reactions"][0];
 export const commentSchema = object({
   id: string(),
   author: authorSchema,
   body: string(),
   edits: array(
     object({
       author: authorSchema,
       body: string(),
       embeds: array(object({ name: string(), content: string() })),
       timestamp: number(),
     }),
   ),
   embeds: array(object({ name: string(), content: string() })),
   reactions: array(object({ emoji: string(), authors: array(authorSchema) })),
   timestamp: number(),
   location: codeLocationSchema.nullable().optional(),
   resolved: boolean(),
   replyTo: string().nullable(),
 });

 import type { ZodSchema, z } from "zod";
 import { array, literal, object, string, union } from "zod";
 import { commentSchema } from "./comment.js";
 import { authorSchema } from "../shared.js";
 export type IssueState =
   | { status: "open" }
   | { status: "closed"; reason: "other" | "solved" };
 const issueStateSchema = union([
   object({ status: literal("open") }),
   object({
     status: literal("closed"),
     reason: union([literal("other"), literal("solved")]),
   }),
 ]) satisfies ZodSchema<IssueState>;
 export const issueSchema = object({
   id: string(),
   author: authorSchema,
   title: string(),
   state: issueStateSchema,
   discussion: array(commentSchema),
   labels: array(string()),
   assignees: array(authorSchema),
 });
 export type Issue = z.infer<typeof issueSchema>;
 export const issuesSchema = array(issueSchema) satisfies ZodSchema<Issue[]>;

   new: rangeSchema.nullable(),
 });
 export type Author = z.infer<typeof authorSchema>;
 export const authorSchema = object({
   id: string(),
   alias: string().optional(),

 import { describe, test } from "vitest";
 import { HttpdClient } from "@http-client";
 import {
   aliceMainHead,
   aliceRemote,
   cobRid,
   defaultHttpdPort,
   sourceBrowsingRid,
 } from "@tests/support/fixtures.js";
 describe("project", () => {
   const api = new HttpdClient({
     hostname: "127.0.0.1",
     port: defaultHttpdPort,
     scheme: "http",
   });
   test("#getByDelegate(delegateId)", async () => {
     await api.project.getByDelegate(aliceRemote);
   });
   test("#getAll()", async () => {
     await api.project.getAll();
   });
   test("#getById(id)", async () => {
     await api.project.getById(sourceBrowsingRid);
   });
   test("#getActivity(id)", async () => {
     await api.project.getActivity(sourceBrowsingRid);
   });
   test("#getReadme(id, sha)", async () => {
     await api.project.getReadme(sourceBrowsingRid, aliceMainHead);
   });
   test("#getBlob(id, sha, path)", async () => {
     await api.project.getBlob(sourceBrowsingRid, aliceMainHead, "src/true.c");
   });
   test("#getTree(id, sha)", async () => {
     await api.project.getTree(sourceBrowsingRid, aliceMainHead);
   });
   test("#getTreeStats(id, sha)", async () => {
     await api.project.getTreeStatsBySha(sourceBrowsingRid, aliceMainHead);
   });
   test("#getTree(id, sha, path)", async () => {
     await api.project.getTree(sourceBrowsingRid, aliceMainHead, "src");
   });
   test("#getAllRemotes(id)", async () => {
     await api.project.getAllRemotes(sourceBrowsingRid);
   });
   test("#getRemoteByPeer(id, peer)", async () => {
     await api.project.getRemoteByPeer(
       sourceBrowsingRid,
       aliceRemote.substring(8),
     );
   });
   test("#getAllCommits(id)", async () => {
     await api.project.getAllCommits(sourceBrowsingRid);
   });
   // TODO: test since/until properly.
   test("#getAllCommits(id, {parent, since, until, page, perPage})", async () => {
     await api.project.getAllCommits(sourceBrowsingRid, {
       parent: aliceMainHead,
       since: 1679065819581,
       until: 1679065819590,
       page: 1,
       perPage: 2,
     });
   });
   test("#getCommitBySha(id, sha)", async () => {
     await api.project.getCommitBySha(sourceBrowsingRid, aliceMainHead);
   });
   test("#getDiff(id, revisionBase, revisionOid)", async () => {
     await api.project.getDiff(
       sourceBrowsingRid,
       "90f6d058ece12f75f349bc7bbe88142187fe0379",
       aliceMainHead,
     );
   });
   test("#getIssueById(id, issueId)", async () => {
     await api.project.getIssueById(
       cobRid,
       "d481fe6e562dd78129589d4738f171a8380fcb19",
     );
   });
   test("#getAllIssues(id)", async () => {
     await api.project.getAllIssues(cobRid, {
       page: 0,
       perPage: 5,
       status: "open",
     });
   });
   test("#getPatchById(id, patchId)", async () => {
     await api.project.getPatchById(
       cobRid,
       "59a0821edc73630bce540596cffc7854da557365",
     );
   });
   test("#getAllPatches(id)", async () => {
     await api.project.getAllPatches(cobRid);
   });
 });

 import { describe, test } from "vitest";
 import { HttpdClient } from "@http-client";
 import {
   aliceMainHead,
   aliceRemote,
   cobRid,
   defaultHttpdPort,
   sourceBrowsingRid,
 } from "@tests/support/fixtures.js";
 describe("repo", () => {
   const api = new HttpdClient({
     hostname: "127.0.0.1",
     port: defaultHttpdPort,
     scheme: "http",
   });
   test("#getByDelegate(delegateId)", async () => {
     await api.repo.getByDelegate(aliceRemote);
   });
   test("#getAll()", async () => {
     await api.repo.getAll();
   });
   test("#getByRid(rid)", async () => {
     await api.repo.getByRid(sourceBrowsingRid);
   });
   test("#getActivity(rid)", async () => {
     await api.repo.getActivity(sourceBrowsingRid);
   });
   test("#getReadme(rid, sha)", async () => {
     await api.repo.getReadme(sourceBrowsingRid, aliceMainHead);
   });
   test("#getBlob(rid, sha, path)", async () => {
     await api.repo.getBlob(sourceBrowsingRid, aliceMainHead, "src/true.c");
   });
   test("#getTree(rid, sha)", async () => {
     await api.repo.getTree(sourceBrowsingRid, aliceMainHead);
   });
   test("#getTreeStats(rid, sha)", async () => {
     await api.repo.getTreeStatsBySha(sourceBrowsingRid, aliceMainHead);
   });
   test("#getTree(rid, sha, path)", async () => {
     await api.repo.getTree(sourceBrowsingRid, aliceMainHead, "src");
   });
   test("#getAllRemotes(rid)", async () => {
     await api.repo.getAllRemotes(sourceBrowsingRid);
   });
   test("#getRemoteByPeer(rid, peer)", async () => {
     await api.repo.getRemoteByPeer(sourceBrowsingRid, aliceRemote.substring(8));
   });
   test("#getAllCommits(rid)", async () => {
     await api.repo.getAllCommits(sourceBrowsingRid);
   });
   // TODO: test since/until properly.
   test("#getAllCommits(rid, {parent, since, until, page, perPage})", async () => {
     await api.repo.getAllCommits(sourceBrowsingRid, {
       parent: aliceMainHead,
       since: 1679065819581,
       until: 1679065819590,
       page: 1,
       perPage: 2,
     });
   });
   test("#getCommitBySha(rid, sha)", async () => {
     await api.repo.getCommitBySha(sourceBrowsingRid, aliceMainHead);
   });
   test("#getDiff(rid, revisionBase, revisionOid)", async () => {
     await api.repo.getDiff(
       sourceBrowsingRid,
       "90f6d058ece12f75f349bc7bbe88142187fe0379",
       aliceMainHead,
     );
   });
   test("#getIssueById(rid, issueId)", async () => {
     await api.repo.getIssueById(
       cobRid,
       "d481fe6e562dd78129589d4738f171a8380fcb19",
     );
   });
   test("#getAllIssues(rid)", async () => {
     await api.repo.getAllIssues(cobRid, {
       page: 0,
       perPage: 5,
       status: "open",
     });
   });
   test("#getPatchByOid(rid, patchId)", async () => {
     await api.repo.getPatchById(
       cobRid,
       "59a0821edc73630bce540596cffc7854da557365",
     );
   });
   test("#getAllPatches(rid)", async () => {
     await api.repo.getAllPatches(cobRid);
   });
 });

 ) {
   expect(
     //@prettier-ignore looks more readable than what prettier suggests.
     isMatch(await api.project.getIssueById(cobRid, oid), change),
     isMatch(await api.repo.getIssueById(cobRid, oid), change),
   ).toBe(true);
 }

       command: "npm run start -- --strictPort --port 3001",
       port: 3001,
     },
     // Required by test tests/e2e/project/commits.spec.ts "loading more commits, adds them to the commits list"
     // Required by test tests/e2e/repo/commits.spec.ts "loading more commits, adds them to the commits list"
     {
       command: "npm run start -- --strictPort --port 3002",
       port: 3002,

 use std::collections::BTreeMap;
 use std::sync::Arc;
 use std::time::Duration;

 use axum::response::{IntoResponse, Json};
 use axum::routing::get;
 use axum::Router;
 use radicle::identity::doc::PayloadId;
 use radicle::issue::cache::Issues as _;
 use radicle::patch::cache::Patches as _;
 use radicle::storage::git::Repository;
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use serde_json::{json, Value};
 use tower_http::cors::{self, CorsLayer};
 use radicle::cob::{issue, patch, Author};

         }
     }
     pub fn project_info<R: ReadRepository + radicle::cob::Store>(
     pub fn repo_info<R: ReadRepository + radicle::cob::Store>(
         &self,
         repo: &R,
         doc: DocAt,
     ) -> Result<project::Info, error::Error> {
         let (_, head) = repo.head()?;
     ) -> Result<repo::Info, error::Error> {
         let DocAt { doc, .. } = doc;
         let id = repo.id();
         let rid = repo.id();
         let payload = doc.project()?;
         let aliases = self.profile.aliases();
         let delegates = doc
             .delegates
             .into_iter()
             .map(|did| json::author(&Author::new(did), aliases.alias(did.as_key())))
             .collect::<Vec<_>>();
         let issues = self.profile.issues(repo)?.counts()?;
         let patches = self.profile.patches(repo)?.counts()?;
         let db = &self.profile.database()?;
         let seeding = db.count(&id).unwrap_or_default();
         Ok(project::Info {
             payload,
         let seeding = db.count(&rid).unwrap_or_default();
         let payloads: BTreeMap<PayloadId, Value> = doc.payload.into_iter()
             .filter_map(|(id, payload)| match id  {
                 id if id == PayloadId::project() => {
                     let Ok((_, head)) = repo.head() else {
                         return None
                     };
                     let (Ok(patches), Ok(issues)) = (self.profile.patches(repo), self.profile.issues(repo)) else {
                         return None
                     };
                     let (Ok(patches), Ok(issues)) = (patches.counts(), issues.counts()) else {
                         return None
                     };
                     Some((id, json!({ "data": payload, "meta": { "head": head, "issues": issues, "patches": patches } } )))
                 },
                 _ => Some((id, json!({ "data": payload })))
               })
             .collect();
         Ok(repo::Info {
             payloads,
             delegates,
             threshold: doc.threshold,
             visibility: doc.visibility,
             head,
             issues,
             patches,
             id,
             rid,
             seeding,
         })
     }

 #[serde(rename_all = "camelCase")]
 pub struct PaginationQuery {
     #[serde(default)]
     pub show: ProjectQuery,
     pub show: RepoQuery,
     pub page: Option<usize>,
     pub per_page: Option<usize>,
 }
 #[derive(Serialize, Deserialize, Clone, Default)]
 #[serde(rename_all = "camelCase")]
 pub enum ProjectQuery {
 pub enum RepoQuery {
     All,
     #[default]
     Pinned,

 mod search {
     use std::cmp::Ordering;
     use std::collections::BTreeMap;
     use nonempty::NonEmpty;
     use serde::{Deserialize, Serialize};
     use serde_json::json;
     use radicle::crypto::Verified;
     use radicle::identity::{Project, RepoId};
     use radicle::identity::doc::{Payload, PayloadId};
     use radicle::identity::RepoId;
     use radicle::node::routing::Store;
     use radicle::node::AliasStore;
     use radicle::node::Database;
     use radicle::node::{AliasStore, Database};
     use radicle::profile::Aliases;
     use radicle::storage::RepositoryInfo;

     #[derive(Serialize, Deserialize, Eq, Debug)]
     pub struct SearchResult {
         pub rid: RepoId,
         #[serde(flatten)]
         pub payload: Project,
         pub payloads: BTreeMap<PayloadId, Payload>,
         pub delegates: NonEmpty<serde_json::Value>,
         pub seeds: usize,
         #[serde(skip)]

             if info.doc.visibility.is_private() {
                 return None;
             }
             let payload = info.doc.project().ok()?;
             let index = payload.name().find(q)?;
             let Ok(Some(index)) = info.doc.project().map(|p| p.name().find(q)) else {
                 return None;
             };
             let seeds = db.count(&info.rid).unwrap_or_default();
             let delegates = info.doc.delegates.map(|did| match aliases.alias(&did) {
                 Some(alias) => json!({

             Some(SearchResult {
                 rid: info.rid,
                 payload,
                 payloads: info.doc.payload,
                 delegates,
                 seeds,
                 index,

     }
 }
 mod project {
 mod repo {
     use std::collections::BTreeMap;
     use serde::Serialize;
     use serde_json::Value;
     use radicle::cob;
     use radicle::git::Oid;
     use radicle::identity::project::Project;
     use radicle::identity::doc::PayloadId;
     use radicle::identity::{RepoId, Visibility};
     /// Project info.
     /// Repos info.
     #[derive(Serialize)]
     #[serde(rename_all = "camelCase")]
     pub struct Info {
         /// Project metadata.
         #[serde(flatten)]
         pub payload: Project,
         pub payloads: BTreeMap<PayloadId, Value>,
         pub delegates: Vec<Value>,
         pub threshold: usize,
         pub visibility: Visibility,
         pub head: Oid,
         pub patches: cob::patch::PatchCounts,
         pub issues: cob::issue::IssueCounts,
         pub id: RepoId,
         pub rid: RepoId,
         pub seeding: usize,
     }
 }

 mod delegates;
 mod node;
 mod projects;
 mod repos;
 mod stats;
 use axum::extract::State;

         .merge(root_router)
         .merge(node::router(ctx.clone()))
         .merge(delegates::router(ctx.clone()))
         .merge(projects::router(ctx.clone()))
         .merge(repos::router(ctx.clone()))
         .merge(stats::router(ctx));
     Router::new().nest("/v1", routes)

         "path": "/api/v1",
         "links": [
             {
                 "href": "/projects",
                 "rel": "projects",
                 "href": "/repos",
                 "rel": "repos",
                 "type": "GET"
             },
             {
                 "href": "/repos/:rid",
                 "rel": "repo",
                 "type": "GET"
             },
             {

 use axum::routing::get;
 use axum::{Json, Router};
 use radicle::cob::Author;
 use radicle::identity::Did;
 use radicle::issue::cache::Issues as _;
 use radicle::node::routing::Store;
 use radicle::node::AliasStore;
 use radicle::patch::cache::Patches as _;
 use radicle::storage::{ReadRepository, ReadStorage};
 use radicle::storage::ReadStorage;
 use crate::api::error::Error;
 use crate::api::json;
 use crate::api::project::Info;
 use crate::api::Context;
 use crate::api::{PaginationQuery, ProjectQuery};
 use crate::api::{Context, PaginationQuery, RepoQuery};
 use crate::axum_extra::{Path, Query};
 pub fn router(ctx: Context) -> Router {
     Router::new()
         .route(
             "/delegates/:delegate/projects",
             get(delegates_projects_handler),
         )
         .route("/delegates/:delegate/repos", get(delegates_repos_handler))
         .with_state(ctx)
 }
 /// List all projects which delegate is a part of.
 /// `GET /delegates/:delegate/projects`
 async fn delegates_projects_handler(
 /// List all repos which delegate is a part of.
 /// `GET /delegates/:delegate/repos`
 async fn delegates_repos_handler(
     State(ctx): State<Context>,
     Path(delegate): Path<Did>,
     Query(qs): Query<PaginationQuery>,

     let page = page.unwrap_or(0);
     let per_page = per_page.unwrap_or(10);
     let storage = &ctx.profile.storage;
     let db = &ctx.profile.database()?;
     let pinned = &ctx.profile.config.web.pinned;
     let mut projects = match show {
         ProjectQuery::All => storage
     let mut repos = match show {
         RepoQuery::All => storage
             .repositories()?
             .into_iter()
             .filter(|repo| repo.doc.visibility.is_public())
             .collect::<Vec<_>>(),
         ProjectQuery::Pinned => storage.repositories_by_id(pinned.repositories.iter())?,
         RepoQuery::Pinned => storage
             .repositories_by_id(pinned.repositories.iter())?
             .into_iter()
             .filter(|repo| repo.doc.visibility.is_public())
             .collect::<Vec<_>>(),
     };
     projects.sort_by_key(|p| p.rid);
     repos.sort_by_key(|p| p.rid);
     let infos = projects
     let infos = repos
         .into_iter()
         .filter_map(|id| {
             if !id.doc.delegates.iter().any(|d| *d == delegate) {
                 return None;
             }
             let Ok(repo) = storage.repository(id.rid) else {
                 return None;
             };
             let Ok((_, head)) = repo.head() else {
                 return None;
             };
             let Ok(payload) = id.doc.project() else {
             let Ok((repo, doc)) = ctx.repo(id.rid) else {
                 return None;
             };
             let Ok(issues) = ctx.profile.issues(&repo) else {
                 return None;
             };
             let Ok(issues) = issues.counts() else {
                 return None;
             };
             let Ok(patches) = ctx.profile.patches(&repo) else {
                 return None;
             };
             let Ok(patches) = patches.counts() else {
             let Ok(repo_info) = ctx.repo_info(&repo, doc) else {
                 return None;
             };
             let aliases = ctx.profile.aliases();
             let delegates = id
                 .doc
                 .delegates
                 .into_iter()
                 .map(|did| json::author(&Author::new(did), aliases.alias(did.as_key())))
                 .collect::<Vec<_>>();
             let seeding = db.count(&id.rid).unwrap_or_default();
             Some(Info {
                 payload,
                 delegates,
                 threshold: id.doc.threshold,
                 visibility: id.doc.visibility,
                 head,
                 issues,
                 patches,
                 id: id.rid,
                 seeding,
             })
             Some(repo_info)
         })
         .skip(page * per_page)
         .take(per_page)

     use crate::test::{self, get, CONTRIBUTOR_ALIAS, DID, HEAD, RID};
     #[tokio::test]
     async fn test_delegates_projects() {
     async fn test_delegates_repos() {
         let tmp = tempfile::tempdir().unwrap();
         let seed = test::seed(tmp.path());
         let app = super::router(seed.clone())
             .layer(MockConnectInfo(SocketAddr::from(([127, 0, 0, 1], 8080))));
         let response = get(
             &app,
             "/delegates/did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/projects?show=all",
             "/delegates/did:key:z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi/repos?show=all",
         )
         .await;

             response.json().await,
             json!([
               {
                 "name": "hello-world",
                 "description": "Rad repository for tests",
                 "defaultBranch": "master",
                 "payloads": {
                   "xyz.radicle.project": {
                     "data": {
                       "defaultBranch": "master",
                       "description": "Rad repository for tests",
                       "name": "hello-world",
                     },
                     "meta": {
                       "head": HEAD,
                       "patches": {
                         "open": 1,
                         "draft": 0,
                         "archived": 0,
                         "merged": 0,
                       },
                       "issues": {
                         "open": 1,
                         "closed": 0,
                       },
                     }
                   }
                 },
                 "delegates": [
                   {
                     "id": DID,

                 "visibility": {
                   "type": "public"
                 },
                 "head": "344dcd184df5bf37aab6c107fa9371a1c5b3321a",
                 "patches": {
                   "open": 0,
                   "draft": 0,
                   "archived": 0,
                   "merged": 0,
                 },
                 "issues": {
                   "open": 0,
                   "closed": 0,
                 },
                 "id": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "rid": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "seeding": 1,
               }
             ])

 use std::collections::{BTreeMap, BTreeSet, HashMap};
 use axum::extract::{DefaultBodyLimit, State};
 use axum::http::header;
 use axum::response::IntoResponse;
 use axum::routing::get;
 use axum::{Json, Router};
 use hyper::StatusCode;
 use radicle_surf::blob::BlobRef;
 use radicle_surf::{diff, Glob, Oid, Repository};
 use serde::{Deserialize, Serialize};
 use serde_json::json;
 use radicle::cob::{issue::cache::Issues as _, patch::cache::Patches as _, Author};
 use radicle::identity::RepoId;
 use radicle::node::routing::Store;
 use radicle::node::{AliasStore, NodeId};
 use radicle::storage::{ReadRepository, ReadStorage, RemoteRepository};
 use crate::api::error::Error;
 use crate::api::project::Info;
 use crate::api::search::{SearchQueryString, SearchResult};
 use crate::api::{self, CobsQuery, Context, PaginationQuery, ProjectQuery};
 use crate::axum_extra::{cached_response, immutable_response, Path, Query};
 const MAX_BODY_LIMIT: usize = 4_194_304;
 pub fn router(ctx: Context) -> Router {
     Router::new()
         .route("/projects", get(project_root_handler))
         .route("/projects/search", get(project_search_handler))
         .route("/projects/:project", get(project_handler))
         .route("/projects/:project/commits", get(history_handler))
         .route("/projects/:project/commits/:sha", get(commit_handler))
         .route("/projects/:project/diff/:base/:oid", get(diff_handler))
         .route("/projects/:project/activity", get(activity_handler))
         .route("/projects/:project/tree/:sha/", get(tree_handler_root))
         .route("/projects/:project/tree/:sha/*path", get(tree_handler))
         .route(
             "/projects/:project/stats/tree/:sha",
             get(stats_tree_handler),
         )
         .route("/projects/:project/remotes", get(remotes_handler))
         .route("/projects/:project/remotes/:peer", get(remote_handler))
         .route("/projects/:project/blob/:sha/*path", get(blob_handler))
         .route("/projects/:project/readme/:sha", get(readme_handler))
         .route("/projects/:project/issues", get(issues_handler))
         .route("/projects/:project/issues/:id", get(issue_handler))
         .route("/projects/:project/patches", get(patches_handler))
         .route("/projects/:project/patches/:id", get(patch_handler))
         .with_state(ctx)
         .layer(DefaultBodyLimit::max(MAX_BODY_LIMIT))
 }
 /// List all projects.
 /// `GET /projects`
 async fn project_root_handler(
     State(ctx): State<Context>,
     Query(qs): Query<PaginationQuery>,
 ) -> impl IntoResponse {
     let PaginationQuery {
         show,
         page,
         per_page,
     } = qs;
     let page = page.unwrap_or(0);
     let per_page = per_page.unwrap_or_else(|| match show {
         ProjectQuery::Pinned => ctx.profile.config.web.pinned.repositories.len(),
         _ => 10,
     });
     let storage = &ctx.profile.storage;
     let db = &ctx.profile.database()?;
     let pinned = &ctx.profile.config.web.pinned;
     let policies = ctx.profile.policies()?;
     let mut projects = match show {
         ProjectQuery::All => storage
             .repositories()?
             .into_iter()
             .filter(|repo| repo.doc.visibility.is_public())
             .collect::<Vec<_>>(),
         ProjectQuery::Pinned => storage
             .repositories_by_id(pinned.repositories.iter())?
             .into_iter()
             .filter(|repo| repo.doc.visibility.is_public())
             .collect::<Vec<_>>(),
     };
     projects.sort_by_key(|p| p.rid);
     let infos = projects
         .into_iter()
         .filter_map(|info| {
             if !policies.is_seeding(&info.rid).unwrap_or_default() {
                 return None;
             }
             let Ok(repo) = storage.repository(info.rid) else {
                 return None;
             };
             let Ok((_, head)) = repo.head() else {
                 return None;
             };
             let Ok(payload) = info.doc.project() else {
                 return None;
             };
             let Ok(issues) = ctx.profile.issues(&repo) else {
                 return None;
             };
             let Ok(issues) = issues.counts() else {
                 return None;
             };
             let Ok(patches) = ctx.profile.patches(&repo) else {
                 return None;
             };
             let Ok(patches) = patches.counts() else {
                 return None;
             };
             let aliases = ctx.profile.aliases();
             let delegates = info
                 .doc
                 .delegates
                 .into_iter()
                 .map(|did| api::json::author(&Author::new(did), aliases.alias(did.as_key())))
                 .collect::<Vec<_>>();
             let seeding = db.count(&info.rid).unwrap_or_default();
             Some(Info {
                 payload,
                 delegates,
                 head,
                 threshold: info.doc.threshold,
                 visibility: info.doc.visibility,
                 issues,
                 patches,
                 id: info.rid,
                 seeding,
             })
         })
         .skip(page * per_page)
         .take(per_page)
         .collect::<Vec<_>>();
     Ok::<_, Error>(Json(infos))
 }
 /// Search repositories by name.
 /// `GET /projects/search?q=<query>`
 ///
 /// We obtain the byte index of the first character of the query that matches the repo name.
 /// And skip if the query doesn't match the repo name.
 ///
 /// Sorting algorithm:
 /// If both byte indices are 0, compare by seeding count.
 /// A repo name with a byte index of 0 should come before non-zero indices.
 /// If both indices are non-zero and equal, then compare by seeding count.
 /// If none of the above, all non-zero indices are compared by their seeding count primarily.
 async fn project_search_handler(
     State(ctx): State<Context>,
     Query(SearchQueryString { q, per_page, page }): Query<SearchQueryString>,
 ) -> impl IntoResponse {
     let q = q.unwrap_or_default();
     let page = page.unwrap_or(0);
     let per_page = per_page.unwrap_or(10);
     let storage = &ctx.profile.storage;
     let aliases = &ctx.profile.aliases();
     let db = &ctx.profile.database()?;
     let found_repos = storage
         .repositories()?
         .into_iter()
         .filter_map(|info| SearchResult::new(&q, info, db, aliases))
         .collect::<BTreeSet<SearchResult>>();
     let found_repos = found_repos
         .into_iter()
         .skip(page * per_page)
         .take(per_page)
         .collect::<Vec<_>>();
     Ok::<_, Error>(cached_response(found_repos, 600).into_response())
 }
 /// Get project metadata.
 /// `GET /projects/:project`
 async fn project_handler(State(ctx): State<Context>, Path(rid): Path<RepoId>) -> impl IntoResponse {
     let (repo, doc) = ctx.repo(rid)?;
     let info = ctx.project_info(&repo, doc)?;
     Ok::<_, Error>(Json(info))
 }
 #[derive(Serialize, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct CommitsQueryString {
     pub parent: Option<String>,
     pub since: Option<i64>,
     pub until: Option<i64>,
     pub page: Option<usize>,
     pub per_page: Option<usize>,
 }
 /// Get project commit range.
 /// `GET /projects/:project/commits?parent=<sha>`
 async fn history_handler(
     State(ctx): State<Context>,
     Path(rid): Path<RepoId>,
     Query(qs): Query<CommitsQueryString>,
 ) -> impl IntoResponse {
     let (repo, doc) = ctx.repo(rid)?;
     let CommitsQueryString {
         since,
         until,
         parent,
         page,
         per_page,
     } = qs;
     // If the parent commit is provided, the response depends only on the query
     // string and not on the state of the repository. This means we can instruct
     // the caches to treat the response as immutable.
     let is_immutable = parent.is_some();
     let sha = match parent {
         Some(commit) => commit,
         None => ctx.project_info(&repo, doc)?.head.to_string(),
     };
     let repo = Repository::open(repo.path())?;
     // If a pagination is defined, we do not want to paginate the commits, and we return all of them on the first page.
     let page = page.unwrap_or(0);
     let per_page = if per_page.is_none() && (since.is_some() || until.is_some()) {
         usize::MAX
     } else {
         per_page.unwrap_or(30)
     };
     let commits = repo
         .history(&sha)?
         .filter_map(|commit| {
             let commit = commit.ok()?;
             let time = commit.committer.time.seconds();
             let commit = api::json::commit(&commit);
             match (since, until) {
                 (Some(since), Some(until)) if time >= since && time < until => Some(commit),
                 (Some(since), None) if time >= since => Some(commit),
                 (None, Some(until)) if time < until => Some(commit),
                 (None, None) => Some(commit),
                 _ => None,
             }
         })
         .skip(page * per_page)
         .take(per_page)
         .collect::<Vec<_>>();
     if is_immutable {
         Ok::<_, Error>(immutable_response(commits).into_response())
     } else {
         Ok::<_, Error>(Json(commits).into_response())
     }
 }
 /// Get project commit.
 /// `GET /projects/:project/commits/:sha`
 async fn commit_handler(
     State(ctx): State<Context>,
     Path((project, sha)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let repo = Repository::open(repo.path())?;
     let commit = repo.commit(sha)?;
     let diff = repo.diff_commit(commit.id)?;
     let glob = Glob::all_heads().branches().and(Glob::all_remotes());
     let branches: Vec<String> = repo
         .revision_branches(commit.id, glob)?
         .iter()
         .map(|b| b.refname().to_string())
         .collect();
     let mut files: HashMap<Oid, BlobRef<'_>> = HashMap::new();
     diff.files().for_each(|file_diff| match file_diff {
         diff::FileDiff::Added(added) => {
             if let Ok(blob) = repo.blob_ref(added.new.oid) {
                 files.insert(blob.id(), blob);
             }
         }
         diff::FileDiff::Deleted(deleted) => {
             if let Ok(old_blob) = repo.blob_ref(deleted.old.oid) {
                 files.insert(old_blob.id(), old_blob);
             }
         }
         diff::FileDiff::Modified(modified) => {
             if let (Ok(old_blob), Ok(new_blob)) = (
                 repo.blob_ref(modified.old.oid),
                 repo.blob_ref(modified.new.oid),
             ) {
                 files.insert(old_blob.id(), old_blob);
                 files.insert(new_blob.id(), new_blob);
             }
         }
         diff::FileDiff::Moved(moved) => {
             if let (Ok(old_blob), Ok(new_blob)) =
                 (repo.blob_ref(moved.old.oid), repo.blob_ref(moved.new.oid))
             {
                 files.insert(old_blob.id(), old_blob);
                 files.insert(new_blob.id(), new_blob);
             }
         }
         diff::FileDiff::Copied(copied) => {
             if let (Ok(old_blob), Ok(new_blob)) =
                 (repo.blob_ref(copied.old.oid), repo.blob_ref(copied.new.oid))
             {
                 files.insert(old_blob.id(), old_blob);
                 files.insert(new_blob.id(), new_blob);
             }
         }
     });
     let response: serde_json::Value = json!({
       "commit": api::json::commit(&commit),
       "diff": diff,
       "files": files,
       "branches": branches
     });
     Ok::<_, Error>(immutable_response(response))
 }
 /// Get diff between two commits
 /// `GET /projects/:project/diff/:base/:oid`
 async fn diff_handler(
     State(ctx): State<Context>,
     Path((project, base, oid)): Path<(RepoId, Oid, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let repo = Repository::open(repo.path())?;
     let base = repo.commit(base)?;
     let commit = repo.commit(oid)?;
     let diff = repo.diff(base.id, commit.id)?;
     let mut files: HashMap<Oid, BlobRef<'_>> = HashMap::new();
     diff.files().for_each(|file_diff| match file_diff {
         diff::FileDiff::Added(added) => {
             if let Ok(new_blob) = repo.blob_ref(added.new.oid) {
                 files.insert(new_blob.id(), new_blob);
             }
         }
         diff::FileDiff::Deleted(deleted) => {
             if let Ok(old_blob) = repo.blob_ref(deleted.old.oid) {
                 files.insert(old_blob.id(), old_blob);
             }
         }
         diff::FileDiff::Modified(modified) => {
             if let (Ok(new_blob), Ok(old_blob)) = (
                 repo.blob_ref(modified.old.oid),
                 repo.blob_ref(modified.new.oid),
             ) {
                 files.insert(new_blob.id(), new_blob);
                 files.insert(old_blob.id(), old_blob);
             }
         }
         diff::FileDiff::Moved(moved) => {
             if let (Ok(new_blob), Ok(old_blob)) =
                 (repo.blob_ref(moved.new.oid), repo.blob_ref(moved.old.oid))
             {
                 files.insert(new_blob.id(), new_blob);
                 files.insert(old_blob.id(), old_blob);
             }
         }
         diff::FileDiff::Copied(copied) => {
             if let (Ok(new_blob), Ok(old_blob)) =
                 (repo.blob_ref(copied.new.oid), repo.blob_ref(copied.old.oid))
             {
                 files.insert(new_blob.id(), new_blob);
                 files.insert(old_blob.id(), old_blob);
             }
         }
     });
     let commits = repo
         .history(commit.id)?
         .take_while(|c| {
             if let Ok(c) = c {
                 c.id != base.id
             } else {
                 false
             }
         })
         .map(|r| r.map(|c| api::json::commit(&c)))
         .collect::<Result<Vec<_>, _>>()?;
     let response = json!({ "diff": diff, "files": files, "commits": commits });
     Ok::<_, Error>(immutable_response(response))
 }
 /// Get project activity for the past year.
 /// `GET /projects/:project/activity`
 async fn activity_handler(
     State(ctx): State<Context>,
     Path(project): Path<RepoId>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let current_date = chrono::Utc::now().timestamp();
     // SAFETY: The number of weeks is static and not out of bounds.
     #[allow(clippy::unwrap_used)]
     let one_year_ago = chrono::Duration::try_weeks(52).unwrap();
     let repo = Repository::open(repo.path())?;
     let head = repo.head()?;
     let timestamps = repo
         .history(head)?
         .filter_map(|a| {
             if let Ok(a) = a {
                 let seconds = a.committer.time.seconds();
                 if seconds > current_date - one_year_ago.num_seconds() {
                     return Some(seconds);
                 }
             }
             None
         })
         .collect::<Vec<i64>>();
     Ok::<_, Error>(cached_response(json!({ "activity": timestamps }), 3600))
 }
 /// Get project source tree for '/' path.
 /// `GET /projects/:project/tree/:sha/`
 async fn tree_handler_root(
     State(ctx): State<Context>,
     Path((rid, sha)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     tree_handler(State(ctx), Path((rid, sha, String::new()))).await
 }
 /// Get project source tree.
 /// `GET /projects/:project/tree/:sha/*path`
 async fn tree_handler(
     State(ctx): State<Context>,
     Path((project, sha, path)): Path<(RepoId, Oid, String)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     if let Some(ref cache) = ctx.cache {
         let cache = &mut cache.tree.lock().await;
         if let Some(response) = cache.get(&(project, sha, path.clone())) {
             return Ok::<_, Error>(immutable_response(response.clone()));
         }
     }
     let repo = Repository::open(repo.path())?;
     let tree = repo.tree(sha, &path)?;
     let response = api::json::tree(&tree, &path);
     if let Some(cache) = &ctx.cache {
         let cache = &mut cache.tree.lock().await;
         cache.put((project, sha, path.clone()), response.clone());
     }
     Ok::<_, Error>(immutable_response(response))
 }
 /// Get project source tree stats.
 /// `GET /projects/:project/stats/tree/:sha`
 async fn stats_tree_handler(
     State(ctx): State<Context>,
     Path((project, sha)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let repo = Repository::open(repo.path())?;
     let stats = repo.stats_from(&sha)?;
     Ok::<_, Error>(immutable_response(stats))
 }
 /// Get all project remotes.
 /// `GET /projects/:project/remotes`
 async fn remotes_handler(
     State(ctx): State<Context>,
     Path(project): Path<RepoId>,
 ) -> impl IntoResponse {
     let (repo, doc) = ctx.repo(project)?;
     let delegates = &doc.delegates;
     let aliases = &ctx.profile.aliases();
     let remotes = repo
         .remotes()?
         .filter_map(|r| r.map(|r| r.1).ok())
         .map(|remote| {
             let refs = remote
                 .refs
                 .iter()
                 .filter_map(|(r, oid)| {
                     r.as_str()
                         .strip_prefix("refs/heads/")
                         .map(|head| (head.to_string(), oid))
                 })
                 .collect::<BTreeMap<String, &Oid>>();
             match aliases.alias(&remote.id) {
                 Some(alias) => json!({
                     "id": remote.id,
                     "alias": alias,
                     "heads": refs,
                     "delegate": delegates.contains(&remote.id.into()),
                 }),
                 None => json!({
                     "id": remote.id,
                     "heads": refs,
                     "delegate": delegates.contains(&remote.id.into()),
                 }),
             }
         })
         .collect::<Vec<_>>();
     Ok::<_, Error>(Json(remotes))
 }
 /// Get project remote.
 /// `GET /projects/:project/remotes/:peer`
 async fn remote_handler(
     State(ctx): State<Context>,
     Path((project, node_id)): Path<(RepoId, NodeId)>,
 ) -> impl IntoResponse {
     let (repo, doc) = ctx.repo(project)?;
     let delegates = &doc.delegates;
     let remote = repo.remote(&node_id)?;
     let refs = remote
         .refs
         .iter()
         .filter_map(|(r, oid)| {
             r.as_str()
                 .strip_prefix("refs/heads/")
                 .map(|head| (head.to_string(), oid))
         })
         .collect::<BTreeMap<String, &Oid>>();
     let remote = json!({
         "id": remote.id,
         "heads": refs,
         "delegate": delegates.contains(&remote.id.into()),
     });
     Ok::<_, Error>(Json(remote))
 }
 /// Get project source file.
 /// `GET /projects/:project/blob/:sha/*path`
 async fn blob_handler(
     State(ctx): State<Context>,
     Path((project, sha, path)): Path<(RepoId, Oid, String)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let repo = Repository::open(repo.path())?;
     let blob = repo.blob(sha, &path)?;
     if blob.size() > MAX_BODY_LIMIT {
         return Ok::<_, Error>(
             (
                 StatusCode::PAYLOAD_TOO_LARGE,
                 [(header::CACHE_CONTROL, "no-cache")],
                 Json(json!([])),
             )
                 .into_response(),
         );
     }
     Ok::<_, Error>(immutable_response(api::json::blob(&blob, &path)).into_response())
 }
 /// Get project readme.
 /// `GET /projects/:project/readme/:sha`
 async fn readme_handler(
     State(ctx): State<Context>,
     Path((project, sha)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let repo = Repository::open(repo.path())?;
     let paths = [
         "README",
         "README.md",
         "README.markdown",
         "README.txt",
         "README.rst",
         "README.org",
         "Readme.md",
     ];
     for path in paths
         .iter()
         .map(ToString::to_string)
         .chain(paths.iter().map(|p| p.to_lowercase()))
     {
         if let Ok(blob) = repo.blob(sha, &path) {
             if blob.size() > MAX_BODY_LIMIT {
                 return Ok::<_, Error>(
                     (
                         StatusCode::PAYLOAD_TOO_LARGE,
                         [(header::CACHE_CONTROL, "no-cache")],
                         Json(json!([])),
                     )
                         .into_response(),
                 );
             }
             return Ok::<_, Error>(
                 immutable_response(api::json::blob(&blob, &path)).into_response(),
             );
         }
     }
     Err(Error::NotFound)
 }
 /// Get project issues list.
 /// `GET /projects/:project/issues`
 async fn issues_handler(
     State(ctx): State<Context>,
     Path(project): Path<RepoId>,
     Query(qs): Query<CobsQuery<api::IssueStatus>>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let CobsQuery {
         page,
         per_page,
         status,
     } = qs;
     let page = page.unwrap_or(0);
     let per_page = per_page.unwrap_or(10);
     let status = status.unwrap_or_default();
     let issues = ctx.profile.issues(&repo)?;
     let mut issues: Vec<_> = issues
         .list()?
         .filter_map(|r| {
             let (id, issue) = r.ok()?;
             (status.matches(issue.state())).then_some((id, issue))
         })
         .collect::<Vec<_>>();
     issues.sort_by(|(_, a), (_, b)| b.timestamp().cmp(&a.timestamp()));
     let aliases = &ctx.profile.aliases();
     let issues = issues
         .into_iter()
         .map(|(id, issue)| api::json::issue(id, issue, aliases))
         .skip(page * per_page)
         .take(per_page)
         .collect::<Vec<_>>();
     Ok::<_, Error>(Json(issues))
 }
 /// Get project issue.
 /// `GET /projects/:project/issues/:id`
 async fn issue_handler(
     State(ctx): State<Context>,
     Path((project, issue_id)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(project)?;
     let issue = ctx
         .profile
         .issues(&repo)?
         .get(&issue_id.into())?
         .ok_or(Error::NotFound)?;
     let aliases = ctx.profile.aliases();
     Ok::<_, Error>(Json(api::json::issue(issue_id.into(), issue, &aliases)))
 }
 /// Get project patches list.
 /// `GET /projects/:project/patches`
 async fn patches_handler(
     State(ctx): State<Context>,
     Path(rid): Path<RepoId>,
     Query(qs): Query<CobsQuery<api::PatchStatus>>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(rid)?;
     let CobsQuery {
         page,
         per_page,
         status,
     } = qs;
     let page = page.unwrap_or(0);
     let per_page = per_page.unwrap_or(10);
     let status = status.unwrap_or_default();
     let patches = ctx.profile.patches(&repo)?;
     let mut patches = patches
         .list()?
         .filter_map(|r| {
             let (id, patch) = r.ok()?;
             (status.matches(patch.state())).then_some((id, patch))
         })
         .collect::<Vec<_>>();
     patches.sort_by(|(_, a), (_, b)| b.timestamp().cmp(&a.timestamp()));
     let aliases = ctx.profile.aliases();
     let patches = patches
         .into_iter()
         .map(|(id, patch)| api::json::patch(id, patch, &repo, &aliases))
         .skip(page * per_page)
         .take(per_page)
         .collect::<Vec<_>>();
     Ok::<_, Error>(Json(patches))
 }
 /// Get project patch.
 /// `GET /projects/:project/patches/:id`
 async fn patch_handler(
     State(ctx): State<Context>,
     Path((rid, patch_id)): Path<(RepoId, Oid)>,
 ) -> impl IntoResponse {
     let (repo, _) = ctx.repo(rid)?;
     let patches = ctx.profile.patches(&repo)?;
     let patch = patches.get(&patch_id.into())?.ok_or(Error::NotFound)?;
     let aliases = ctx.profile.aliases();
     Ok::<_, Error>(Json(api::json::patch(
         patch_id.into(),
         patch,
         &repo,
         &aliases,
     )))
 }
 #[cfg(test)]
 mod routes {
     use std::net::SocketAddr;
     use axum::extract::connect_info::MockConnectInfo;
     use axum::http::StatusCode;
     use pretty_assertions::assert_eq;
     use radicle::storage::ReadStorage;
     use serde_json::json;
     use crate::test::*;
     #[tokio::test]
     async fn test_projects_root() {
         let tmp = tempfile::tempdir().unwrap();
         let seed = seed(tmp.path());
         let app = super::router(seed.clone())
             .layer(MockConnectInfo(SocketAddr::from(([127, 0, 0, 1], 8080))));
         let response = get(&app, "/projects?show=all").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "name": "hello-world",
                 "description": "Rad repository for tests",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   },
                 ],
                 "threshold": 1,
                 "visibility": {
                   "type": "public"
                 },
                 "head": HEAD,
                 "patches": {
                   "open": 1,
                   "draft": 0,
                   "archived": 0,
                   "merged": 0,
                 },
                 "issues": {
                   "open": 1,
                   "closed": 0,
                 },
                 "id": RID,
                 "seeding": 1,
               },
               {
                 "name": "again-hello-world",
                 "description": "Rad repository for sorting",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   }
                 ],
                 "threshold": 1,
                 "visibility": {
                   "type": "public"
                 },
                 "head": "344dcd184df5bf37aab6c107fa9371a1c5b3321a",
                 "patches": {
                   "open": 0,
                   "draft": 0,
                   "archived": 0,
                   "merged": 0,
                 },
                 "issues": {
                   "open": 0,
                   "closed": 0,
                 },
                 "id": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "seeding": 1,
               },
             ])
         );
         let app = super::router(seed).layer(MockConnectInfo(SocketAddr::from((
             [192, 168, 13, 37],
 ,
         ))));
         let response = get(&app, "/projects?show=all").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "name": "hello-world",
                 "description": "Rad repository for tests",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   }
                 ],
                 "threshold": 1,
                 "visibility": {
                   "type": "public"
                 },
                 "head": HEAD,
                 "patches": {
                   "open": 1,
                   "draft": 0,
                   "archived": 0,
                   "merged": 0,
                 },
                 "issues": {
                   "open": 1,
                   "closed": 0,
                 },
                 "id": RID,
                 "seeding": 1,
               },
               {
                 "name": "again-hello-world",
                 "description": "Rad repository for sorting",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   },
                 ],
                 "threshold": 1,
                 "visibility": {
                   "type": "public"
                 },
                 "head": "344dcd184df5bf37aab6c107fa9371a1c5b3321a",
                 "patches": {
                   "open": 0,
                   "draft": 0,
                   "archived": 0,
                   "merged": 0,
                 },
                 "issues": {
                   "open": 0,
                   "closed": 0,
                 },
                 "id": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "seeding": 1,
               },
             ])
         );
     }
     #[tokio::test]
     async fn test_projects() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                "name": "hello-world",
                "description": "Rad repository for tests",
                "defaultBranch": "master",
                "delegates": [
                  {
                    "id": DID,
                    "alias": CONTRIBUTOR_ALIAS,
                  }
                ],
                "threshold": 1,
                "visibility": {
                  "type": "public"
                },
                "head": HEAD,
                "patches": {
                  "open": 1,
                  "draft": 0,
                  "archived": 0,
                  "merged": 0,
                },
                "issues": {
                  "open": 1,
                  "closed": 0,
                },
                "id": RID,
                "seeding": 1,
             })
         );
     }
     #[tokio::test]
     async fn test_search_projects() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, "/projects/search?q=hello").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "rid": "rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp",
                 "name": "hello-world",
                 "description": "Rad repository for tests",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   }
                 ],
                 "seeds": 1,
               },
               {
                 "rid": "rad:z4GypKmh1gkEfmkXtarcYnkvtFUfE",
                 "name": "again-hello-world",
                 "description": "Rad repository for sorting",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS
                   },
                 ],
                 "seeds": 1,
               },
             ])
         );
     }
     #[tokio::test]
     async fn test_search_projects_pagination() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, "/projects/search?q=hello&perPage=1").await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "rid": "rad:z4FucBZHZMCsxTyQE1dfE2YR59Qbp",
                 "name": "hello-world",
                 "description": "Rad repository for tests",
                 "defaultBranch": "master",
                 "delegates": [
                   {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS,
                   }
                 ],
                 "seeds": 1,
               },
             ])
         );
     }
     #[tokio::test]
     async fn test_projects_not_found() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, "/projects/rad:z2u2CP3ZJzB7ZqE8jHrau19yjcfCQ").await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
     #[tokio::test]
     async fn test_projects_commits_root() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/commits")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
                 {
                   "id": HEAD,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz"
                   },
                   "summary": "Add another folder",
                   "description": "",
                   "parents": [
                     "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                   ],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673003014
                   },
                 },
                 {
                   "id": PARENT,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz"
                   },
                   "summary": "Add contributing file",
                   "description": "",
                   "parents": [
                     "f604ce9fd5b7cc77b7609beda45ea8760bee78f7",
                   ],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673002014,
                   },
                 },
                 {
                   "id": INITIAL_COMMIT,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                   },
                   "summary": "Initial commit",
                   "description": "",
                   "parents": [],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673001014,
                   },
                 },
             ])
         );
     }
     #[tokio::test]
     async fn test_projects_commits() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/commits/{HEAD}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
               "commit": {
                 "id": HEAD,
                 "author": {
                   "name": "Alice Liddell",
                   "email": "alice@radicle.xyz"
                 },
                 "summary": "Add another folder",
                 "description": "",
                 "parents": [
                   "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                 ],
                 "committer": {
                   "name": "Alice Liddell",
                   "email": "alice@radicle.xyz",
                   "time": 1673003014
                 },
               },
               "diff": {
                 "files": [
                   {
                     "state": "deleted",
                     "path": "CONTRIBUTING",
                     "diff": {
                       "type": "plain",
                       "hunks": [
                         {
                           "header": "@@ -1 +0,0 @@\n",
                           "lines": [
                             {
                               "line": "Thank you very much!\n",
                               "lineNo": 1,
                               "type": "deletion",
                             },
                           ],
                           "old":  {
                             "start": 1,
                             "end": 2,
                           },
                           "new": {
                             "start": 0,
                             "end": 0,
                           },
                         },
                       ],
                       "stats": {
                         "additions": 0,
                         "deletions": 1,
                       },
                       "eof": "noneMissing",
                     },
                     "old": {
                       "oid": "82eb77880c693655bce074e3dbbd9fa711dc018b",
                       "mode": "blob",
                     },
                   },
                   {
                     "state": "added",
                     "path": "README",
                     "diff": {
                       "type": "plain",
                       "hunks": [
                         {
                           "header": "@@ -0,0 +1 @@\n",
                           "lines": [
                             {
                               "line": "Hello World!\n",
                               "lineNo": 1,
                               "type": "addition",
                             },
                           ],
                           "old":  {
                             "start": 0,
                             "end": 0,
                           },
                           "new": {
                             "start": 1,
                             "end": 2,
                           },
                         },
                       ],
                       "stats": {
                         "additions": 1,
                         "deletions": 0,
                       },
                       "eof": "noneMissing",
                     },
                     "new": {
                       "oid": "980a0d5f19a64b4b30a87d4206aade58726b60e3",
                       "mode": "blob",
                     },
                   },
                   {
                     "state": "added",
                     "path": "dir1/README",
                     "diff": {
                       "type": "plain",
                       "hunks": [
                         {
                           "header": "@@ -0,0 +1 @@\n",
                           "lines": [
                             {
                               "line": "Hello World from dir1!\n",
                               "lineNo": 1,
                               "type": "addition"
                             }
                           ],
                           "old":  {
                             "start": 0,
                             "end": 0,
                           },
                           "new": {
                             "start": 1,
                             "end": 2,
                           },
                         }
                       ],
                       "stats": {
                         "additions": 1,
                         "deletions": 0,
                       },
                       "eof": "noneMissing",
                     },
                     "new": {
                       "oid": "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1",
                       "mode": "blob",
                     },
                   },
                 ],
                 "stats": {
                   "filesChanged": 3,
                   "insertions": 2,
                   "deletions": 1
                 }
               },
               "files": {
                 "82eb77880c693655bce074e3dbbd9fa711dc018b": {
                   "id": "82eb77880c693655bce074e3dbbd9fa711dc018b",
                   "binary": false,
                   "content": "Thank you very much!\n",
                 },
                 "980a0d5f19a64b4b30a87d4206aade58726b60e3": {
                   "id": "980a0d5f19a64b4b30a87d4206aade58726b60e3",
                   "binary": false,
                   "content": "Hello World!\n",
                 },
                 "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1": {
                   "id": "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1",
                   "binary": false,
                   "content": "Hello World from dir1!\n",
                 },
               },
               "branches": [
                 "refs/heads/master"
               ]
             })
         );
     }
     #[tokio::test]
     async fn test_projects_commits_not_found() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(
             &app,
             format!("/projects/{RID}/commits/ffffffffffffffffffffffffffffffffffffffff"),
         )
         .await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
     #[tokio::test]
     async fn test_projects_stats() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/stats/tree/{HEAD}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!(
               {
                 "commits": 3,
                 "branches": 1,
                 "contributors": 1
               }
             )
         );
     }
     #[tokio::test]
     async fn test_projects_tree() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/tree/{HEAD}/")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "entries": [
                   {
                     "path": "dir1",
                     "oid": "2d1c3cbfcf1d190d7fc77ac8f9e53db0e91a9ad3",
                     "name": "dir1",
                     "kind": "tree"
                   },
                   {
                     "path": "README",
                     "oid": "980a0d5f19a64b4b30a87d4206aade58726b60e3",
                     "name": "README",
                     "kind": "blob"
                   }
                 ],
                 "lastCommit": {
                   "id": HEAD,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz"
                   },
                   "summary": "Add another folder",
                   "description": "",
                   "parents": [
                     "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                   ],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673003014
                   },
                 },
                 "name": "",
                 "path": "",
               }
             )
         );
         let response = get(&app, format!("/projects/{RID}/tree/{HEAD}/dir1")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
               "entries": [
                 {
                   "path": "dir1/README",
                   "oid": "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1",
                   "name": "README",
                   "kind": "blob"
                 }
               ],
               "lastCommit": {
                 "id": HEAD,
                 "author": {
                   "name": "Alice Liddell",
                   "email": "alice@radicle.xyz"
                 },
                 "summary": "Add another folder",
                 "description": "",
                 "parents": [
                   "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                 ],
                 "committer": {
                   "name": "Alice Liddell",
                   "email": "alice@radicle.xyz",
                   "time": 1673003014
                 },
               },
               "name": "dir1",
               "path": "dir1",
             })
         );
     }
     #[tokio::test]
     async fn test_projects_tree_not_found() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(
             &app,
             format!("/projects/{RID}/tree/ffffffffffffffffffffffffffffffffffffffff"),
         )
         .await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let response = get(&app, format!("/projects/{RID}/tree/{HEAD}/unknown")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
     #[tokio::test]
     async fn test_projects_remotes_root() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/remotes")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "id": "z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi",
                 "alias": CONTRIBUTOR_ALIAS,
                 "heads": {
                   "master": HEAD
                 },
                 "delegate": true
               }
             ])
         );
     }
     #[tokio::test]
     async fn test_projects_remotes() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(
             &app,
             format!("/projects/{RID}/remotes/z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi"),
         )
         .await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "id": "z6MknSLrJoTcukLrE435hVNQT4JUhbvWLX4kUzqkEStBU8Vi",
                 "heads": {
                     "master": HEAD
                 },
                 "delegate": true
             })
         );
     }
     #[tokio::test]
     async fn test_projects_remotes_not_found() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(
             &app,
             format!("/projects/{RID}/remotes/z6MksFqXN3Yhqk8pTJdUGLwATkRfQvwZXPqR2qMEhbS9wzpT"),
         )
         .await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
     #[tokio::test]
     async fn test_projects_blob() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/blob/{HEAD}/README")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "binary": false,
                 "name": "README",
                 "path": "README",
                 "lastCommit": {
                   "id": HEAD,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz"
                   },
                   "summary": "Add another folder",
                   "description": "",
                   "parents": [
                     "ee8d6a29304623a78ebfa5eeed5af674d0e58f83"
                   ],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673003014
                   },
                 },
                 "content": "Hello World!\n",
             })
         );
     }
     #[tokio::test]
     async fn test_projects_blob_not_found() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/blob/{HEAD}/unknown")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
     #[tokio::test]
     async fn test_projects_readme() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/readme/{INITIAL_COMMIT}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "binary": false,
                 "name": "README",
                 "path": "README",
                 "lastCommit": {
                   "id": INITIAL_COMMIT,
                   "author": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz"
                   },
                   "summary": "Initial commit",
                   "description": "",
                   "parents": [],
                   "committer": {
                     "name": "Alice Liddell",
                     "email": "alice@radicle.xyz",
                     "time": 1673001014
                   },
                 },
                 "content": "Hello World!\n"
             })
         );
     }
     #[tokio::test]
     async fn test_projects_diff() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(
             &app,
             format!("/projects/{RID}/diff/{INITIAL_COMMIT}/{HEAD}"),
         )
         .await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "diff": {
                   "files": [
                     {
                       "state": "added",
                       "path": "dir1/README",
                       "diff": {
                         "type": "plain",
                         "hunks": [
                           {
                             "header": "@@ -0,0 +1 @@\n",
                             "lines": [
                               {
                                 "line": "Hello World from dir1!\n",
                                 "lineNo": 1,
                                 "type": "addition",
                               },
                             ],
                             "old":  {
                               "start": 0,
                               "end": 0,
                             },
                             "new": {
                               "start": 1,
                               "end": 2,
                             },
                           },
                         ],
                         "stats": {
                           "additions": 1,
                           "deletions": 0,
                         },
                         "eof": "noneMissing",
                       },
                       "new": {
                         "oid": "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1",
                         "mode": "blob",
                       },
                     },
                   ],
                   "stats": {
                     "filesChanged": 1,
                     "insertions": 1,
                     "deletions": 0,
                   },
                 },
                 "files": {
                   "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1": {
                     "id": "1dd5654ca2d2cf9f33b14c92b5ca9e1d21a91ae1",
                     "binary": false,
                     "content": "Hello World from dir1!\n",
                   },
                 },
                 "commits": [
                   {
                     "id": HEAD,
                     "author": {
                       "name": "Alice Liddell",
                       "email": "alice@radicle.xyz",
                     },
                     "summary": "Add another folder",
                     "description": "",
                     "parents": [
                       "ee8d6a29304623a78ebfa5eeed5af674d0e58f83"
                     ],
                     "committer": {
                       "name": "Alice Liddell",
                       "email": "alice@radicle.xyz",
                       "time": 1673003014,
                     },
                   },
                   {
                     "id": PARENT,
                     "author": {
                       "name": "Alice Liddell",
                       "email": "alice@radicle.xyz",
                     },
                     "summary": "Add contributing file",
                     "description": "",
                     "parents": [
                       "f604ce9fd5b7cc77b7609beda45ea8760bee78f7",
                     ],
                     "committer": {
                       "name": "Alice Liddell",
                       "email": "alice@radicle.xyz",
                       "time": 1673002014,
                     }
                   }
                 ],
             })
         );
     }
     #[tokio::test]
     async fn test_projects_issues_root() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/issues")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
               {
                 "id": ISSUE_ID,
                 "author": {
                   "id": DID,
                   "alias": CONTRIBUTOR_ALIAS
                 },
                 "title": "Issue #1",
                 "state": {
                   "status": "open"
                 },
                 "assignees": [],
                 "discussion": [
                   {
                     "id": ISSUE_ID,
                     "author": {
                       "id": DID,
                       "alias": CONTRIBUTOR_ALIAS
                     },
                     "body": "Change 'hello world' to 'hello everyone'",
                     "edits": [
                       {
                         "author": {
                           "id": DID,
                           "alias": CONTRIBUTOR_ALIAS
                         },
                         "body": "Change 'hello world' to 'hello everyone'",
                         "timestamp": TIMESTAMP,
                         "embeds": [],
                       },
                     ],
                     "embeds": [],
                     "reactions": [],
                     "timestamp": TIMESTAMP,
                     "replyTo": null,
                     "resolved": false,
                   }
                 ],
                 "labels": []
               }
             ])
         );
     }
     #[tokio::test]
     async fn test_projects_issue() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/issues/{ISSUE_ID}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "id": ISSUE_ID,
                 "author": {
                   "id": DID,
                   "alias": CONTRIBUTOR_ALIAS
                 },
                 "title": "Issue #1",
                 "state": {
                   "status": "open"
                 },
                 "assignees": [],
                 "discussion": [
                   {
                     "id": ISSUE_ID,
                     "author": {
                       "id": DID,
                       "alias": CONTRIBUTOR_ALIAS
                     },
                     "body": "Change 'hello world' to 'hello everyone'",
                     "edits": [
                       {
                         "author": {
                           "id": DID,
                           "alias": CONTRIBUTOR_ALIAS
                         },
                         "body": "Change 'hello world' to 'hello everyone'",
                         "timestamp": TIMESTAMP,
                         "embeds": [],
                       },
                     ],
                     "embeds": [],
                     "reactions": [],
                     "timestamp": TIMESTAMP,
                     "replyTo": null,
                     "resolved": false,
                   }
                 ],
                 "labels": []
             })
         );
     }
     #[tokio::test]
     async fn test_projects_patches_root() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/patches")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!([
                 {
                     "id": PATCH_ID,
                     "author": {
                         "id": DID,
                         "alias": CONTRIBUTOR_ALIAS,
                     },
                     "title": "A new `hello world`",
                     "state": {
                         "status": "open",
                     },
                     "target": "delegates",
                     "labels": [],
                     "merges": [],
                     "assignees": [],
                     "revisions": [
                         {
                             "id": PATCH_ID,
                             "author": {
                                 "id": DID,
                                 "alias": CONTRIBUTOR_ALIAS,
                             },
                             "description": "change `hello world` in README to something else",
                             "edits": [
                                 {
                                     "author": {
                                         "id": DID,
                                         "alias": CONTRIBUTOR_ALIAS,
                                     },
                                     "body": "change `hello world` in README to something else",
                                     "timestamp": TIMESTAMP,
                                     "embeds": [],
                                 },
                             ],
                             "reactions": [],
                             "base": "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                             "oid": "e8c676b9e3b42308dc9d218b70faa5408f8e58ca",
                             "refs": [
                                 "refs/heads/master",
                             ],
                             "discussions": [],
                             "timestamp": TIMESTAMP,
                             "reviews": [],
                         },
                     ],
                 },
                 ]
             )
         );
     }
     #[tokio::test]
     async fn test_projects_patch() {
         let tmp = tempfile::tempdir().unwrap();
         let app = super::router(seed(tmp.path()));
         let response = get(&app, format!("/projects/{RID}/patches/{PATCH_ID}")).await;
         assert_eq!(response.status(), StatusCode::OK);
         assert_eq!(
             response.json().await,
             json!({
                 "id": PATCH_ID,
                 "author": {
                     "id": DID,
                     "alias": CONTRIBUTOR_ALIAS,
                 },
                 "title": "A new `hello world`",
                 "state": {
                     "status": "open",
                 },
                 "target": "delegates",
                 "labels": [],
                 "merges": [],
                 "assignees": [],
                 "revisions": [
                     {
                         "id": PATCH_ID,
                         "author": {
                             "id": DID,
                             "alias": CONTRIBUTOR_ALIAS,
                         },
                         "description": "change `hello world` in README to something else",
                         "edits": [
                             {
                                 "author": {
                                     "id": DID,
                                     "alias": CONTRIBUTOR_ALIAS,
                                 },
                                 "body": "change `hello world` in README to something else",
                                 "timestamp": TIMESTAMP,
                                 "embeds": [],
                             },
                         ],
                         "reactions": [],
                         "base": "ee8d6a29304623a78ebfa5eeed5af674d0e58f83",
                         "oid": "e8c676b9e3b42308dc9d218b70faa5408f8e58ca",
                         "refs": [
                             "refs/heads/master",
                         ],
                         "discussions": [],
                         "timestamp": TIMESTAMP,
                         "reviews": [],
                     },
                 ],
             })
         );
     }
     #[tokio::test]
     async fn test_projects_private() {
         let tmp = tempfile::tempdir().unwrap();
         let ctx = seed(tmp.path());
         let app = super::router(ctx.to_owned());
         // Check that the repo exists.
         ctx.profile()
             .storage
             .repository(RID_PRIVATE.parse().unwrap())
             .unwrap();
         let response = get(&app, format!("/projects/{RID_PRIVATE}")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let response = get(&app, format!("/projects/{RID_PRIVATE}/patches")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let response = get(&app, format!("/projects/{RID_PRIVATE}/issues")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let response = get(&app, format!("/projects/{RID_PRIVATE}/commits")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
         let response = get(&app, format!("/projects/{RID_PRIVATE}/remotes")).await;
         assert_eq!(response.status(), StatusCode::NOT_FOUND);
     }
 }

 pub fn router(profile: Arc<Profile>, aliases: HashMap<String, RepoId>) -> Router {
     Router::new()
         .route("/:project/*request", any(git_handler))
         .route("/:rid/*request", any(git_handler))
         .with_state((profile, aliases))
 }
 async fn git_handler(
     State((profile, aliases)): State<(Arc<Profile>, HashMap<String, RepoId>)>,
     AxumPath((project, request)): AxumPath<(String, String)>,
     AxumPath((repository, request)): AxumPath<(String, String)>,
     method: Method,
     headers: HeaderMap,
     ConnectInfo(remote): ConnectInfo<SocketAddr>,