hanna/fabrica

feat: repository forks

0add8bf · hanna committed on 2026-07-26

Add repos.fork_parent_id (migration 0016) and the fork flow:

- A "Fork" button in the repo header (signed-in viewers) links to a
  confirm page; POST creates a repo under the viewer, copies the source's
  refs on disk (create_bare + a local git fetch), and records the parent.
- The fork inherits the source's visibility, default branch, object
  format, and description; a name collision in the viewer's namespace is
  reported.
- Forks show a "forked from owner/repo" line under the slug. Store gains
  set_fork_parent and count_forks; RepoCtx carries the viewer id and the
  resolved parent for display.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Signed by hannaSSH key fingerprint: SHA256:4g9cWhkAAw8gwqhJUcVbSnGEvdGwklW+1Aa/fMUu59k

assets/base.css +8 −0

crates/auth/src/access.rs +1 −0

crates/model/src/entity.rs +2 −0

crates/store/src/repos.rs +32 −2

crates/store/src/tests.rs +32 −0

crates/web/src/lib.rs +4 −0

crates/web/src/repo.rs +214 −0

migrations/postgres/0016_repo_fork.sql +3 −0

migrations/sqlite/0016_repo_fork.sql +3 −0

@@ @@ -2002,6 +2002,14 @@ pre.code { @@
 .repo-head {
   margin-bottom: 1.25rem;
+}
 /* "forked from owner/repo" line under the repo slug. */
 .fork-note {
   display: flex;
   align-items: center;
   gap: 0.3rem;
   font-size: 0.9em;
   margin: 0.2rem 0 0;
+}
 .repo-slug {
   display: flex;
   align-items: center;

@@ @@ -151,6 +151,7 @@ mod tests { @@
             issues_enabled: true,
             pulls_enabled: true,
             is_mirror: false,
             fork_parent_id: None,
             next_iid: 1,
             archived_at: None,
             size_bytes: 0,

@@ @@ -427,6 +427,8 @@ pub struct Repo { @@
     pub pulls_enabled: bool,
     /// Whether this repository is a mirror (kept in sync from a remote).
     pub is_mirror: bool,
     /// The repository this one was forked from, if any.
     pub fork_parent_id: Option<String>,
     /// The next issue/PR number to allocate (shared counter).
     pub next_iid: Timestamp,
     /// When the repo was archived (read-only), if it is.

@@ @@ -12,8 +12,8 @@ use crate::{Store, StoreError, map_conflict, new_id, now_ms}; @@
 /// The columns of `repos` in a fixed order, shared by every `SELECT`.
 const REPO_COLUMNS: &str = "id, owner_id, group_id, name, path, description, visibility, \
      default_branch, object_format, issues_enabled, pulls_enabled, is_mirror, next_iid, \
      archived_at, size_bytes, pushed_at, created_at, updated_at";
      default_branch, object_format, issues_enabled, pulls_enabled, is_mirror, fork_parent_id, \
      next_iid, archived_at, size_bytes, pushed_at, created_at, updated_at";
 /// Fields needed to create a repository. The server fills in the id, timestamps,
 /// and the derived size/push bookkeeping.
@@ @@ -70,6 +70,7 @@ impl Store { @@
             issues_enabled: true,
             pulls_enabled: true,
             is_mirror: false,
             fork_parent_id: None,
             next_iid: 1,
             archived_at: None,
             size_bytes: 0,
@@ @@ -306,6 +307,34 @@ impl Store { @@
         Ok(updated > 0)
+    }
     /// Record that `repo_id` was forked from `parent_id`.
     ///
     /// # Errors
     ///
     /// Returns [`StoreError::Query`] on a database failure.
     pub async fn set_fork_parent(&self, repo_id: &str, parent_id: &str) -> Result<(), StoreError> {
         sqlx::query("UPDATE repos SET fork_parent_id = $1 WHERE id = $2")
             .bind(parent_id)
             .bind(repo_id)
             .execute(&self.pool)
             .await?;
         Ok(())
+    }
     /// The number of repositories forked from `repo_id`.
     ///
     /// # Errors
     ///
     /// Returns [`StoreError::Query`] on a database failure.
     pub async fn count_forks(&self, repo_id: &str) -> Result<i64, StoreError> {
         let n: i64 = sqlx::query("SELECT COUNT(*) AS n FROM repos WHERE fork_parent_id = $1")
             .bind(repo_id)
             .fetch_one(&self.pool)
             .await?
             .try_get("n")?;
         Ok(n)
+    }
     /// Archive or unarchive a repository. Archiving stamps `archived_at`;
     /// unarchiving clears it. Returns `true` if the row existed and was updated.
     ///
@@ @@ -467,6 +496,7 @@ impl Store { @@
             issues_enabled: self.get_bool(row, "issues_enabled")?,
             pulls_enabled: self.get_bool(row, "pulls_enabled")?,
             is_mirror: self.get_bool(row, "is_mirror")?,
             fork_parent_id: row.try_get("fork_parent_id")?,
             next_iid: row.try_get("next_iid")?,
             archived_at: row.try_get("archived_at")?,
             size_bytes: row.try_get("size_bytes")?,

@@ @@ -825,6 +825,38 @@ async fn ensure_group_path_rejects_excessive_nesting() { @@
+}
 #[tokio::test]
 async fn fork_parent_and_count_round_trip() {
     for fx in sqlite_fixtures().await {
         let owner = fx
             .store
             .create_user(sample_user("fk", "fk@example.com"))
             .await
             .unwrap();
         let mk = |name: &str| NewRepo {
             owner_id: owner.id.clone(),
             group_id: None,
             name: name.to_string(),
             path: name.to_string(),
             description: None,
             visibility: model::Visibility::Public,
             default_branch: "main".to_string(),
         };
         let parent = fx.store.create_repo(mk("upstream")).await.unwrap();
         let fork = fx.store.create_repo(mk("myfork")).await.unwrap();
         assert!(fork.fork_parent_id.is_none());
         assert_eq!(fx.store.count_forks(&parent.id).await.unwrap(), 0);
         fx.store
             .set_fork_parent(&fork.id, &parent.id)
             .await
             .unwrap();
         let reloaded = fx.store.repo_by_id(&fork.id).await.unwrap().unwrap();
         assert_eq!(reloaded.fork_parent_id.as_deref(), Some(parent.id.as_str()));
         assert_eq!(fx.store.count_forks(&parent.id).await.unwrap(), 1);
+    }
+}
 #[tokio::test]
 async fn mirrors_create_list_due_and_delete() {
     for fx in sqlite_fixtures().await {
         let owner = fx

@@ @@ -315,6 +315,10 @@ pub fn build_router(state: AppState) -> Router { @@
             "/new/migrate",
             get(pages::migrate_form).post(pages::migrate_submit),
+        )
         .route(
             "/repo-fork/{id}",
             get(repo::fork_confirm).post(repo::fork_create),
+        )
         // Issue/PR mutations: fixed prefixes so they never hit the repo catch-all.
         .route("/issue-new/{repo_id}", post(issues::create))
         .route("/issue/{id}/comment", post(issues::comment))

@@ @@ -76,6 +76,10 @@ pub(crate) struct RepoCtx { @@
     /// The viewer's access level, used to gate the Settings tab and its actions.
     /// Every browse view requires only `Read`.
     pub(crate) access: auth::Access,
     /// The signed-in viewer's id, if any (gates the Fork action).
     pub(crate) viewer_id: Option<String>,
     /// The parent repo's `(owner_username, path)` when this repo is a fork.
     pub(crate) fork_parent: Option<(String, String)>,
+}
 /// Run a blocking libgit2 read for a repo on the blocking pool, opening the repo
@@ @@ -144,13 +148,32 @@ pub(crate) async fn resolve( @@
     if access == auth::Access::None {
         return Err(AppError::NotFound);
+    }
     // Resolve the fork parent's owner/path for the "forked from" line (best-effort).
     let fork_parent = match &repo.fork_parent_id {
         Some(pid) => resolve_fork_parent(state, pid).await,
         None => None,
     };
     Ok(Some(RepoCtx {
         owner,
         repo,
         access,
         viewer_id: viewer.map(|u| u.id.clone()),
         fork_parent,
     }))
+}
 /// Resolve a parent repo id to its `(owner_username, path)` for display.
 async fn resolve_fork_parent(state: &AppState, parent_id: &str) -> Option<(String, String)> {
     let parent = state.store.repo_by_id(parent_id).await.ok().flatten()?;
     let owner = state
         .store
         .user_by_id(&parent.owner_id)
         .await
         .ok()
         .flatten()?;
     Some((owner.username, parent.path))
+}
 /// A listing filter query (`?q=`), shared by the profile and explore views.
 #[derive(Debug, Default, Deserialize)]
 pub struct ListQuery {
@@ @@ -1560,6 +1583,186 @@ pub async fn settings_mirror_sync( @@
+    }
+}
 /// Load a repo by id and require the viewer to be able to read it, else `404`.
 async fn require_readable_repo(
     state: &AppState,
     viewer: Option<&User>,
     repo_id: &str,
 ) -> Result<Repo, AppError> {
     let repo = state
         .store
         .repo_by_id(repo_id)
         .await?
         .ok_or(AppError::NotFound)?;
     let viewer_id = viewer.map(|u| auth::Viewer {
         id: u.id.clone(),
         is_admin: u.is_admin,
     });
     let collaborator = match viewer {
         Some(u) => state
             .store
             .collaborator_permission(&repo.id, &u.id)
             .await?
             .and_then(|p| auth::Permission::parse(&p)),
         None => None,
     };
     let access = auth::access(
         viewer_id.as_ref(),
         &repo,
         collaborator,
         state.allow_anonymous(),
     );
     if access == auth::Access::None {
         return Err(AppError::NotFound);
+    }
     Ok(repo)
+}
 /// `GET /repo-fork/{id}` — confirm forking a readable repo to your account.
 pub async fn fork_confirm(
     State(state): State<AppState>,
     MaybeUser(viewer): MaybeUser,
     jar: CookieJar,
     uri: Uri,
     Path(id): Path<String>,
 ) -> AppResult<Response> {
     let Some(user) = viewer.clone() else {
         return Ok(Redirect::to("/login").into_response());
     };
     let source = require_readable_repo(&state, viewer.as_ref(), &id).await?;
     let source_owner = state
         .store
         .user_by_id(&source.owner_id)
         .await?
         .ok_or(AppError::NotFound)?;
     let (jar, chrome) = build_chrome(&state, jar, Some(user.clone()), uri.path().to_string());
     let body = html! {
         div class="new-repo" {
             h1 { "Fork a repository" }
             div class="card" {
                 p { "Create a copy of "
                     strong { (source_owner.username) "/" (source.path) }
                     " under your account, " strong { (user.username) } "." }
                 form method="post" action=(format!("/repo-fork/{}", source.id)) {
                     input type="hidden" name="_csrf" value=(chrome.csrf);
                     label for="fk-name" { "Repository name" }
                     input type="text" id="fk-name" name="name" value=(source.name) required;
                     button class="btn btn-primary inline-btn" type="submit" { "Fork repository" }
+                }
+            }
+        }
     };
     Ok((jar, page(&chrome, "Fork a repository", body)).into_response())
+}
 /// The fork form.
 #[derive(Debug, serde::Deserialize)]
 pub struct ForkForm {
     #[serde(default)]
     name: String,
     #[serde(rename = "_csrf")]
     csrf: String,
+}
 /// `POST /repo-fork/{id}` — create the fork (row + on-disk copy) and redirect.
 pub async fn fork_create(
     State(state): State<AppState>,
     MaybeUser(viewer): MaybeUser,
     jar: CookieJar,
     headers: HeaderMap,
     Path(id): Path<String>,
     Form(form): Form<ForkForm>,
 ) -> Response {
     if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
         return AppError::Forbidden.into_response();
+    }
     let Some(user) = viewer.clone() else {
         return Redirect::to("/login").into_response();
     };
     let source = match require_readable_repo(&state, viewer.as_ref(), &id).await {
         Ok(repo) => repo,
         Err(e) => return e.into_response(),
     };
     match do_fork(&state, &user, &source, form.name.trim()).await {
         Ok(path) => Redirect::to(&format!("/{}/{path}", user.username)).into_response(),
         Err(msg) => AppError::BadRequest(msg).into_response(),
+    }
+}
 /// Create the fork repo (row + bare repo on disk seeded from the source).
 async fn do_fork(
     state: &AppState,
     user: &User,
     source: &Repo,
     name: &str,
 ) -> Result<String, String> {
     let leaf = name.trim();
     if leaf.is_empty() {
         return Err("Repository name is required.".to_string());
+    }
     let repo = state
         .store
         .create_repo(store::NewRepo {
             owner_id: user.id.clone(),
             group_id: None,
             name: leaf.to_string(),
             path: leaf.to_string(),
             description: source.description.clone(),
             visibility: source.visibility,
             default_branch: source.default_branch.clone(),
         })
         .await
         .map_err(|e| match e {
             store::StoreError::Conflict { .. } => {
                 "You already have a repository with that name.".to_string()
+            }
             store::StoreError::Name(_) => "Invalid repository name.".to_string(),
             other => other.to_string(),
         })?;
     let _ = state.store.set_fork_parent(&repo.id, &source.id).await;
     let format = git::ObjectFormat::from_token(&source.object_format);
     if format != git::ObjectFormat::Sha1 {
         let _ = state
             .store
             .set_object_format(&repo.id, format.as_str())
             .await;
+    }
     let repo_dir = &state.config.storage.repo_dir;
     let hook = std::env::current_exe().unwrap_or_else(|_| std::path::PathBuf::from("fabrica"));
     if let Err(e) =
         git::create_bare_with_format(repo_dir, &repo.id, &source.default_branch, &hook, format)
+    {
         let _ = state.store.delete_repo(&repo.id).await;
         return Err(format!("Could not create the fork on disk: {e}"));
+    }
     // Seed the fork by fetching the source's refs over a local path.
     let (Ok(src_dir), Ok(dest_dir)) = (
         git::repo_path(repo_dir, &source.id),
         git::repo_path(repo_dir, &repo.id),
     ) else {
         let _ = state.store.delete_repo(&repo.id).await;
         return Err("Could not locate the repositories on disk.".to_string());
     };
     let home = state.config.storage.data_dir.join("tmp");
     let src_url = src_dir.to_string_lossy().into_owned();
     if let Err(e) = git::mirror::fetch(
         &state.config.git.binary,
         &dest_dir,
         &src_url,
         git::mirror::RemoteCred::default(),
         &home,
+    )
     .await
+    {
         let _ = state.store.delete_repo(&repo.id).await;
         return Err(format!("Could not copy the repository contents: {e}"));
+    }
     let size = i64::try_from(crate::admin::dir_size(&dest_dir)).unwrap_or(0);
     let _ = state.store.record_push(&repo.id, size).await;
     Ok(repo.path)
+}
 /// Resolve a repo by id and require the viewer to have `Admin` access, else a
 /// `404` (so a non-admin cannot even confirm the repo exists).
 async fn require_admin_repo(
@@ @@ -2615,6 +2818,12 @@ pub(crate) fn repo_header( @@
                 (visibility_badge(ctx.repo.visibility))
                 (archived_badge(ctx.repo.archived_at.is_some()))
+            }
             @if let Some((powner, ppath)) = &ctx.fork_parent {
                 p class="muted fork-note" {
                     (icon(Icon::Mirror)) " forked from "
                     a href=(format!("/{powner}/{ppath}")) { (powner) "/" (ppath) }
+                }
+            }
             @if let Some(desc) = &ctx.repo.description { p class="muted" { (desc) } }
             div class="repo-nav" {
                 nav class="tabs repo-tabs" {
@@ @@ -2633,6 +2842,11 @@ pub(crate) fn repo_header( @@
+                    }
+                }
                 div class="repo-actions" {
                     @if ctx.viewer_id.is_some() {
                         a class="btn" href=(format!("/repo-fork/{}", ctx.repo.id)) {
                             (icon(Icon::GitBranch)) span { "Fork" }
+                        }
+                    }
                     (branch_menu(&base, rev, branches))
                     (clone_menu(state, ctx))
+                }

@@ @@ -0,0 +1,3 @@ @@
 -- Fork relationship: a repo created as a fork points at its parent. The parent
 -- surviving a fork means renames are metadata-only; deleting a parent detaches.
 ALTER TABLE repos ADD COLUMN fork_parent_id TEXT REFERENCES repos(id) ON DELETE SET NULL;