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

 .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;

             issues_enabled: true,
             pulls_enabled: true,
             is_mirror: false,
+            fork_parent_id: None,
             next_iid: 1,
             archived_at: None,
             size_bytes: 0,

     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.

 /// 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, \
+     default_branch, object_format, issues_enabled, pulls_enabled, is_mirror, fork_parent_id, \
-     archived_at, size_bytes, pushed_at, created_at, updated_at";
+     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.
             issues_enabled: true,
             pulls_enabled: true,
             is_mirror: false,
+            fork_parent_id: None,
             next_iid: 1,
             archived_at: None,
             size_bytes: 0,
         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.
     ///
             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")?,

+}
 #[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

             "/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))

     /// 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
     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 {
+    }
+}
+/// 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(
                 (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" {
+                    }
+                }
                 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))
+                }

+-- 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;