hanna/fabrica

feat: scoped labels and per-repo issue/PR toggles

dd10faf · hanna committed on 2026-07-25

Add the collaboration schema (migration 0005: per-repo issues_enabled/
pulls_enabled/next_iid, labels, issues, comments, issue_labels,
pull_requests), the Label/Issue/Comment/PullRequest/IssueState model types,
and store label CRUD + feature toggles. Repo Settings gains a Labels section
(coloured chips, scoped kind: value names, add/delete) and Issues/Pull
requests enable checkboxes in General.

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

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

assets/base.css +37 −0

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

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

crates/model/src/lib.rs +4 −1

crates/store/src/labels.rs +140 −0

crates/store/src/lib.rs +1 −0

crates/store/src/repos.rs +36 −4

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

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

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

migrations/postgres/0005_collaboration.sql +59 −0

migrations/sqlite/0005_collaboration.sql +60 −0

   display: inline;
+}
+/* Labels. */
+.label-chip {
+  display: inline-flex;
+  align-items: center;
+  padding: 0.1rem 0.55rem;
+  border-radius: 999px;
+  font-size: 0.85em;
+  font-weight: 600;
+  color: #fff;
+  background: var(--label-color, #888);
+  border: 1px solid rgba(0, 0, 0, 0.25);
+}
+.label-list .entry-row-body {
+  display: flex;
+  flex-direction: column;
+  gap: 0.25rem;
+  align-items: flex-start;
+}
+.label-add {
+  display: flex;
+  gap: 0.5rem;
+  flex-wrap: wrap;
+  align-items: stretch;
+}
+.label-add input[type="text"] {
+  flex: 1;
+  min-width: 10rem;
+}
+.label-add input[type="color"] {
+  width: 2.6rem;
+  padding: 0.15rem;
+  height: 2.4rem;
+}
+.label-add button {
+  flex: none;
+}
 /* Repo settings danger zone. */
 .danger-zone {
   border-color: var(--fb-danger);

             description: None,
             visibility,
             default_branch: "main".to_string(),
+            issues_enabled: true,
+            pulls_enabled: true,
+            next_iid: 1,
             archived_at: None,
             size_bytes: 0,
             pushed_at: None,

     pub created_at: Timestamp,
+}
+/// A per-repo issue/PR label, optionally **scoped** (`kind: value`, e.g.
+/// `type: backend`). Scoped labels are mutually exclusive within their scope.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Label {
+    /// ULID primary key.
+    pub id: String,
+    /// Owning repository.
+    pub repo_id: String,
+    /// The label name, e.g. `bug` or `type: backend`.
+    pub name: String,
+    /// Hex colour (`#rrggbb`).
+    pub color: String,
+    /// Optional description.
+    pub description: Option<String>,
+    /// Creation time.
+    pub created_at: Timestamp,
+}
+impl Label {
+    /// The label's scope (`kind`) when it is `kind: value`, else `None`.
+    #[must_use]
+    pub fn scope(&self) -> Option<&str> {
+        self.name.split_once(": ").map(|(scope, _)| scope.trim())
+    }
+}
+/// Whether an issue/PR is open or closed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum IssueState {
+    /// Open.
+    Open,
+    /// Closed.
+    Closed,
+}
+impl IssueState {
+    /// The database token (`open` / `closed`).
+    #[must_use]
+    pub fn as_str(self) -> &'static str {
+        match self {
+            Self::Open => "open",
+            Self::Closed => "closed",
+        }
+    }
+    /// Parse from the database token.
+    #[must_use]
+    pub fn from_token(s: &str) -> Self {
+        if s == "closed" {
+            Self::Closed
+        } else {
+            Self::Open
+        }
+    }
+}
+/// An issue or (when `is_pull`) a pull request. Both share the `issues` table and
+/// the per-repo number counter, so `#N` is unique across both.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Issue {
+    /// ULID primary key.
+    pub id: String,
+    /// Owning repository.
+    pub repo_id: String,
+    /// The per-repo number shown as `#N`.
+    pub number: Timestamp,
+    /// The author.
+    pub author_id: String,
+    /// Title.
+    pub title: String,
+    /// Markdown body.
+    pub body: String,
+    /// Open or closed.
+    pub state: IssueState,
+    /// Whether this row is a pull request.
+    pub is_pull: bool,
+    /// The assignee, if any.
+    pub assignee_id: Option<String>,
+    /// Creation time.
+    pub created_at: Timestamp,
+    /// Last update time.
+    pub updated_at: Timestamp,
+    /// When it was closed, if it is.
+    pub closed_at: Option<Timestamp>,
+}
+/// A comment on an issue or pull request.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Comment {
+    /// ULID primary key.
+    pub id: String,
+    /// The issue/PR this comment belongs to.
+    pub issue_id: String,
+    /// The author.
+    pub author_id: String,
+    /// Markdown body.
+    pub body: String,
+    /// Creation time.
+    pub created_at: Timestamp,
+    /// Last edit time.
+    pub updated_at: Timestamp,
+}
+/// The pull-request side table for an `issues` row with `is_pull = 1`.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PullRequest {
+    /// The `issues` row id.
+    pub issue_id: String,
+    /// The base ref (merged into).
+    pub base_ref: String,
+    /// The head ref (source of the changes).
+    pub head_ref: String,
+    /// When it was merged, if it has been.
+    pub merged_at: Option<Timestamp>,
+    /// Who merged it.
+    pub merged_by: Option<String>,
+    /// The resulting merge commit sha.
+    pub merge_sha: Option<String>,
+    /// The strategy used (`merge` | `squash` | `rebase`).
+    pub merge_strategy: Option<String>,
+}
 /// A git repository. On disk it lives at `{repo_dir}/{id[0..2]}/{id}.git`; the
 /// database is the sole authority mapping `(owner, path)` to this id.
 #[derive(Debug, Clone, PartialEq, Eq)]
     pub visibility: Visibility,
     /// The branch shown by default and used for HEAD.
     pub default_branch: String,
+    /// Whether issues are enabled for this repository.
+    pub issues_enabled: bool,
+    /// Whether pull requests are enabled for this repository.
+    pub pulls_enabled: bool,
+    /// The next issue/PR number to allocate (shared counter).
+    pub next_iid: Timestamp,
     /// When the repo was archived (read-only), if it is.
     pub archived_at: Option<Timestamp>,
     /// Approximate on-disk size in bytes, refreshed by maintenance.

 pub mod entity;
 pub mod name;
-pub use entity::{ApiToken, Group, Invite, Key, KeyKind, Repo, Timestamp, User, Visibility};
+pub use entity::{
+    ApiToken, Comment, Group, Invite, Issue, IssueState, Key, KeyKind, Label, PullRequest, Repo,
+    Timestamp, User, Visibility,
+};
 pub use name::{MAX_NAME_LEN, NameError, RESERVED_NAMES, validate_name};

+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+//! Per-repository issue/PR labels (optionally scoped `kind: value`).
+use model::Label;
+use sqlx::any::AnyRow;
+use sqlx::{AssertSqlSafe, Row};
+use crate::{Store, StoreError, map_conflict, new_id, now_ms};
+/// The columns of `labels` in a fixed order.
+const LABEL_COLUMNS: &str = "id, repo_id, name, color, description, created_at";
+impl Store {
+    /// Create a label on a repo. Names are unique per repo, case-insensitively.
+    ///
+    /// # Errors
+    ///
+    /// * [`StoreError::Conflict`] if the name is already used in the repo.
+    /// * [`StoreError::Query`] for any other database failure.
+    pub async fn create_label(
+        &self,
+        repo_id: &str,
+        name: &str,
+        color: &str,
+        description: Option<&str>,
+    ) -> Result<Label, StoreError> {
+        let label = Label {
+            id: new_id(),
+            repo_id: repo_id.to_string(),
+            name: name.to_string(),
+            color: color.to_string(),
+            description: description.map(str::to_string),
+            created_at: now_ms(),
+        };
+        let sql = "INSERT INTO labels (id, repo_id, name, name_lower, color, description, created_at) \
+             VALUES ($1, $2, $3, $4, $5, $6, $7)";
+        sqlx::query(sql)
+            .bind(&label.id)
+            .bind(&label.repo_id)
+            .bind(&label.name)
+            .bind(label.name.to_lowercase())
+            .bind(&label.color)
+            .bind(&label.description)
+            .bind(label.created_at)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| map_conflict(e, "label", &[("name", "name")]))?;
+        Ok(label)
+    }
+    /// List a repo's labels, alphabetical (scoped labels group naturally).
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn list_labels(&self, repo_id: &str) -> Result<Vec<Label>, StoreError> {
+        let sql = format!(
+            "SELECT {LABEL_COLUMNS} FROM labels WHERE repo_id = $1 ORDER BY name_lower ASC"
+        );
+        let rows = sqlx::query(AssertSqlSafe(sql))
+            .bind(repo_id)
+            .fetch_all(&self.pool)
+            .await?;
+        rows.iter()
+            .map(map_label)
+            .collect::<Result<_, _>>()
+            .map_err(Into::into)
+    }
+    /// Fetch a label by id.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn label_by_id(&self, id: &str) -> Result<Option<Label>, StoreError> {
+        let sql = format!("SELECT {LABEL_COLUMNS} FROM labels WHERE id = $1");
+        let row = sqlx::query(AssertSqlSafe(sql))
+            .bind(id)
+            .fetch_optional(&self.pool)
+            .await?;
+        Ok(row.as_ref().map(map_label).transpose()?)
+    }
+    /// Update a label's name, colour, and description.
+    ///
+    /// # Errors
+    ///
+    /// * [`StoreError::Conflict`] if the new name collides in the repo.
+    /// * [`StoreError::Query`] for any other database failure.
+    pub async fn update_label(
+        &self,
+        id: &str,
+        name: &str,
+        color: &str,
+        description: Option<&str>,
+    ) -> Result<bool, StoreError> {
+        let sql = "UPDATE labels SET name = $1, name_lower = $2, color = $3, description = $4 \
+             WHERE id = $5";
+        let updated = sqlx::query(sql)
+            .bind(name)
+            .bind(name.to_lowercase())
+            .bind(color)
+            .bind(description)
+            .bind(id)
+            .execute(&self.pool)
+            .await
+            .map_err(|e| map_conflict(e, "label", &[("name", "name")]))?
+            .rows_affected();
+        Ok(updated > 0)
+    }
+    /// Delete a label (cascading to `issue_labels`). Returns `true` if removed.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn delete_label(&self, id: &str) -> Result<bool, StoreError> {
+        let deleted = sqlx::query("DELETE FROM labels WHERE id = $1")
+            .bind(id)
+            .execute(&self.pool)
+            .await?
+            .rows_affected();
+        Ok(deleted > 0)
+    }
+}
+/// Map a `labels` row to a [`Label`].
+fn map_label(row: &AnyRow) -> Result<Label, sqlx::Error> {
+    Ok(Label {
+        id: row.try_get("id")?,
+        repo_id: row.try_get("repo_id")?,
+        name: row.try_get("name")?,
+        color: row.try_get("color")?,
+        description: row.try_get("description")?,
+        created_at: row.try_get("created_at")?,
+    })
+}

 mod groups;
 mod invites;
 mod keys;
+mod labels;
 mod repos;
 mod sessions;
 mod tokens;

 /// 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, archived_at, size_bytes, pushed_at, created_at, updated_at";
+     default_branch, issues_enabled, pulls_enabled, 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.
             description: new.description,
             visibility: new.visibility,
             default_branch: new.default_branch,
+            issues_enabled: true,
+            pulls_enabled: true,
+            next_iid: 1,
             archived_at: None,
             size_bytes: 0,
             pushed_at: None,
         Ok(updated > 0)
+    }
+    /// Enable or disable issues / pull requests for a repository. `feature` is
+    /// `"issues"` or `"pulls"`. Returns `true` if the row was updated.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`StoreError::Query`] on a database failure.
+    pub async fn set_feature_enabled(
+        &self,
+        repo_id: &str,
+        feature: &str,
+        enabled: bool,
+    ) -> Result<bool, StoreError> {
+        let column = match feature {
+            "issues" => "issues_enabled",
+            "pulls" => "pulls_enabled",
+            _ => return Ok(false),
+        };
+        let sql = format!("UPDATE repos SET {column} = $1, updated_at = $2 WHERE id = $3");
+        let updated = sqlx::query(AssertSqlSafe(sql))
+            .bind(enabled)
+            .bind(now_ms())
+            .bind(repo_id)
+            .execute(&self.pool)
+            .await?
+            .rows_affected();
+        Ok(updated > 0)
+    }
     /// Archive or unarchive a repository. Archiving stamps `archived_at`;
     /// unarchiving clears it. Returns `true` if the row existed and was updated.
     ///
+    }
     /// Map a `repos` row (selected via [`REPO_COLUMNS`]) to a [`Repo`].
-    // A method (not an associated fn) for symmetry with the other row mappers,
-    // even though the visibility mapping no longer needs `self`.
-    #[allow(clippy::unused_self)]
     fn map_repo(&self, row: &AnyRow) -> Result<Repo, sqlx::Error> {
         Ok(Repo {
             id: row.try_get("id")?,
             visibility: Visibility::from_token(&row.try_get::<String, _>("visibility")?)
                 .unwrap_or(Visibility::Private),
             default_branch: row.try_get("default_branch")?,
+            issues_enabled: self.get_bool(row, "issues_enabled")?,
+            pulls_enabled: self.get_bool(row, "pulls_enabled")?,
+            next_iid: row.try_get("next_iid")?,
             archived_at: row.try_get("archived_at")?,
             size_bytes: row.try_get("size_bytes")?,
             pushed_at: row.try_get("pushed_at")?,

+}
 #[tokio::test]
+async fn labels_create_list_delete() {
+    for fx in sqlite_fixtures().await {
+        let owner = fx
+            .store
+            .create_user(sample_user("lo", "lo@example.com"))
+            .await
+            .unwrap();
+        let repo = fx
+            .store
+            .create_repo(NewRepo {
+                owner_id: owner.id,
+                group_id: None,
+                name: "r".to_string(),
+                path: "r".to_string(),
+                description: None,
+                visibility: model::Visibility::Private,
+                default_branch: "main".to_string(),
+            })
+            .await
+            .unwrap();
+        // New repos default to issues/PRs enabled.
+        assert!(repo.issues_enabled && repo.pulls_enabled);
+        let label = fx
+            .store
+            .create_label(&repo.id, "type: backend", "#ff0000", Some("server code"))
+            .await
+            .unwrap();
+        assert_eq!(label.scope(), Some("type"));
+        // Duplicate name (case-insensitive) conflicts.
+        let dup = fx
+            .store
+            .create_label(&repo.id, "Type: Backend", "#00ff00", None)
+            .await;
+        assert!(matches!(dup, Err(StoreError::Conflict { .. })));
+        let list = fx.store.list_labels(&repo.id).await.unwrap();
+        assert_eq!(list.len(), 1);
+        assert!(fx.store.delete_label(&label.id).await.unwrap());
+        assert!(fx.store.list_labels(&repo.id).await.unwrap().is_empty());
+        // Feature toggles round-trip.
+        assert!(
+            fx.store
+                .set_feature_enabled(&repo.id, "issues", false)
+                .await
+                .unwrap()
+        );
+        let repo = fx.store.repo_by_id(&repo.id).await.unwrap().unwrap();
+        assert!(!repo.issues_enabled);
+    }
+}
+#[tokio::test]
 async fn collaborators_add_update_list_remove() {
     for fx in sqlite_fixtures().await {
         let owner = fx

             "/repo-settings/{id}/collaborators/remove",
             post(repo::settings_collaborator_remove),
+        )
+        .route("/repo-settings/{id}/labels", post(repo::settings_label_add))
+        .route(
+            "/repo-settings/{id}/labels/delete",
+            post(repo::settings_label_delete),
+        )
         .route("/healthz", get(serve_assets::healthz))
         .route("/version", get(serve_assets::version))
         .route("/theme.css", get(serve_assets::theme_default))

+    }
     let branches = branch_names(state, &ctx.repo.id).await;
     let collaborators = state.store.list_collaborators(&ctx.repo.id).await?;
+    let labels = state.store.list_labels(&ctx.repo.id).await?;
     let (jar, chrome) = build_chrome(state, jar, viewer, uri.path().to_string());
     let id = &ctx.repo.id;
                         (vis_option(Visibility::Internal, "Internal — any signed-in user"))
                         (vis_option(Visibility::Private, "Private — only you and collaborators"))
+                    }
+                    label { "Features" }
+                    label class="checkbox" {
+                        input type="checkbox" name="issues_enabled" value="1"
+                              checked[ctx.repo.issues_enabled]; " Issues"
+                    }
+                    label class="checkbox" {
+                        input type="checkbox" name="pulls_enabled" value="1"
+                              checked[ctx.repo.pulls_enabled]; " Pull requests"
+                    }
+                }
                 div class="settings-actions" {
                     button class="btn btn-primary" type="submit" form="repo-general" { "Save changes" }
+            }
+        }
         (collaborators_section(id, &chrome.csrf, &collaborators))
+        (labels_section(id, &chrome.csrf, &labels))
         section class="listing" {
             h2 { "Danger zone" }
             div class="card danger-zone" {
+    }
+}
+/// A coloured label chip.
+fn label_chip(label: &model::Label) -> Markup {
+    html! {
+        span class="label-chip" style=(format!("--label-color: {}", css_color(&label.color))) {
+            (label.name)
+        }
+    }
+}
+/// Sanitize a stored colour for inline CSS: only `#` + up to 8 hex digits.
+fn css_color(color: &str) -> String {
+    let hex: String = color
+        .trim_start_matches('#')
+        .chars()
+        .filter(char::is_ascii_hexdigit)
+        .take(8)
+        .collect();
+    if hex.is_empty() {
+        "#888888".to_string()
+    } else {
+        format!("#{hex}")
+    }
+}
+/// The Labels section of the repo settings page.
+fn labels_section(id: &str, csrf: &str, labels: &[model::Label]) -> Markup {
+    html! {
+        section class="listing" {
+            h2 { "Labels" }
+            div class="card" {
+                @if labels.is_empty() {
+                    p class="muted" { "No labels yet. Use a scope like " code { "type: backend" } " for grouped labels." }
+                } @else {
+                    ul class="entry-list label-list" {
+                        @for l in labels {
+                            li class="entry-row" {
+                                div class="entry-row-body" {
+                                    (label_chip(l))
+                                    @if let Some(desc) = &l.description {
+                                        div class="entry-row-meta muted" { (desc) }
+                                    }
+                                }
+                                div class="entry-row-actions" {
+                                    form method="post" action=(format!("/repo-settings/{id}/labels/delete")) {
+                                        input type="hidden" name="_csrf" value=(csrf);
+                                        input type="hidden" name="label_id" value=(l.id);
+                                        button class="btn btn-danger" type="submit" { "Delete" }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                form class="label-add" method="post" action=(format!("/repo-settings/{id}/labels")) {
+                    input type="hidden" name="_csrf" value=(csrf);
+                    input type="text" name="name" placeholder="name or scope: value" aria-label="Label name" required;
+                    input type="color" name="color" value="#2f81f7" aria-label="Colour";
+                    input type="text" name="description" placeholder="Description (optional)" aria-label="Description";
+                    button class="btn btn-primary inline-btn" type="submit" { "Add label" }
+                }
+            }
+        }
+    }
+}
+/// The add-label form.
+#[derive(Debug, Deserialize)]
+pub struct LabelAddForm {
+    /// Label name (may be `scope: value`).
+    #[serde(default)]
+    name: String,
+    /// Hex colour.
+    #[serde(default)]
+    color: String,
+    /// Optional description.
+    #[serde(default)]
+    description: String,
+    /// CSRF token.
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /repo-settings/{id}/labels` — create a label.
+pub async fn settings_label_add(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path(id): Path<String>,
+    Form(form): Form<LabelAddForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    let result = async {
+        let repo = require_admin_repo(&state, viewer.as_ref(), &id).await?;
+        let name = form.name.trim();
+        if name.is_empty() {
+            return Err(AppError::BadRequest("Label name is required.".to_string()));
+        }
+        let color = css_color(&form.color);
+        let desc = form.description.trim();
+        state
+            .store
+            .create_label(&repo.id, name, &color, (!desc.is_empty()).then_some(desc))
+            .await
+            .map_err(|e| match e {
+                store::StoreError::Conflict { .. } => {
+                    AppError::BadRequest("A label with that name already exists.".to_string())
+                }
+                other => AppError::from(other),
+            })?;
+        Ok::<String, AppError>(repo_settings_url(&state, &repo).await)
+    }
+    .await;
+    match result {
+        Ok(dest) => Redirect::to(&dest).into_response(),
+        Err(err) => err.into_response(),
+    }
+}
+/// The delete-label form.
+#[derive(Debug, Deserialize)]
+pub struct LabelDeleteForm {
+    /// The label id.
+    #[serde(default)]
+    label_id: String,
+    /// CSRF token.
+    #[serde(rename = "_csrf")]
+    csrf: String,
+}
+/// `POST /repo-settings/{id}/labels/delete` — delete a label.
+pub async fn settings_label_delete(
+    State(state): State<AppState>,
+    MaybeUser(viewer): MaybeUser,
+    jar: CookieJar,
+    headers: HeaderMap,
+    Path(id): Path<String>,
+    Form(form): Form<LabelDeleteForm>,
+) -> Response {
+    if verify_csrf(&jar, &headers, Some(&form.csrf)).is_err() {
+        return AppError::Forbidden.into_response();
+    }
+    let result = async {
+        let repo = require_admin_repo(&state, viewer.as_ref(), &id).await?;
+        // Only delete a label that belongs to this repo.
+        if let Some(label) = state.store.label_by_id(&form.label_id).await?
+            && label.repo_id == repo.id
+        {
+            state.store.delete_label(&label.id).await?;
+        }
+        Ok::<String, AppError>(repo_settings_url(&state, &repo).await)
+    }
+    .await;
+    match result {
+        Ok(dest) => Redirect::to(&dest).into_response(),
+        Err(err) => err.into_response(),
+    }
+}
 /// 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(
     /// The chosen visibility token.
     #[serde(default)]
     visibility: String,
+    /// Enable issues (checkbox present when on).
+    #[serde(default)]
+    issues_enabled: Option<String>,
+    /// Enable pull requests.
+    #[serde(default)]
+    pulls_enabled: Option<String>,
     /// CSRF token.
     #[serde(rename = "_csrf")]
     csrf: String,
         if let Some(vis) = Visibility::from_token(&form.visibility) {
             state.store.set_visibility(&repo.id, vis).await?;
+        }
+        state
+            .store
+            .set_feature_enabled(&repo.id, "issues", form.issues_enabled.is_some())
+            .await?;
+        state
+            .store
+            .set_feature_enabled(&repo.id, "pulls", form.pulls_enabled.is_some())
+            .await?;
         let owner = state
             .store
             .user_by_id(&repo.owner_id)

+-- Collaboration: per-repo toggles + shared issue/PR number counter, labels,
+-- issues (with is_pull discriminator), comments, issue↔label join, and the PR
+-- side table. Issues and PRs share the `issues` table and `repos.next_iid`.
+ALTER TABLE repos ADD COLUMN issues_enabled BOOLEAN NOT NULL DEFAULT TRUE;
+ALTER TABLE repos ADD COLUMN pulls_enabled  BOOLEAN NOT NULL DEFAULT TRUE;
+ALTER TABLE repos ADD COLUMN next_iid       BIGINT  NOT NULL DEFAULT 1;
+CREATE TABLE labels (
+    id          TEXT PRIMARY KEY,
+    repo_id     TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+    name        TEXT NOT NULL,
+    name_lower  TEXT NOT NULL,
+    color       TEXT NOT NULL,
+    description TEXT,
+    created_at  BIGINT NOT NULL
+);
+CREATE UNIQUE INDEX idx_labels_repo_name ON labels (repo_id, name_lower);
+CREATE TABLE issues (
+    id          TEXT PRIMARY KEY,
+    repo_id     TEXT NOT NULL REFERENCES repos(id) ON DELETE CASCADE,
+    number      BIGINT NOT NULL,
+    author_id   TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    title       TEXT NOT NULL,
+    body        TEXT NOT NULL,
+    state       TEXT NOT NULL DEFAULT 'open',
+    is_pull     BOOLEAN NOT NULL DEFAULT FALSE,
+    assignee_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+    created_at  BIGINT NOT NULL,
+    updated_at  BIGINT NOT NULL,
+    closed_at   BIGINT
+);
+CREATE UNIQUE INDEX idx_issues_repo_number ON issues (repo_id, number);
+CREATE INDEX idx_issues_repo_state ON issues (repo_id, is_pull, state);
+CREATE TABLE comments (
+    id         TEXT PRIMARY KEY,
+    issue_id   TEXT NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
+    author_id  TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+    body       TEXT NOT NULL,
+    created_at BIGINT NOT NULL,
+    updated_at BIGINT NOT NULL
+);
+CREATE TABLE issue_labels (
+    issue_id TEXT NOT NULL REFERENCES issues(id) ON DELETE CASCADE,
+    label_id TEXT NOT NULL REFERENCES labels(id) ON DELETE CASCADE,
+    PRIMARY KEY (issue_id, label_id)
+);
+CREATE TABLE pull_requests (
+    issue_id       TEXT PRIMARY KEY REFERENCES issues(id) ON DELETE CASCADE,
+    base_ref       TEXT NOT NULL,
+    head_ref       TEXT NOT NULL,
+    merged_at      BIGINT,
+    merged_by      TEXT REFERENCES users(id) ON DELETE SET NULL,
+    merge_sha      TEXT,
+    merge_strategy TEXT
+);