gitbay/Repos/RepoSettingsViewModel.swift

  1import Foundation
  2import Observation
  3
  4/// The repo settings screen: `repo settings show` for the admin knobs,
  5/// `repo show` for description/topics/visibility, and one write command
  6/// per control. Non-admins get the server's refusal verbatim.
  7@Observable
  8@MainActor
  9final class RepoSettingsViewModel {
 10
 11    nonisolated struct Loaded: Sendable, Hashable {
 12        let settings: RepoSettings
 13        let detail: RepoDetail
 14    }
 15
 16    private(set) var state: LoadState<Loaded> = .loading
 17    private(set) var actionError: String?
 18    private(set) var working = false
 19
 20    /// `repo deps status`, exposed as an optional plus a separate error
 21    /// string rather than folded into one state: `nil` with no error means
 22    /// "not loaded yet", `nil` with an error means "the read failed". The
 23    /// settings screen must never render "checks are off" when it means
 24    /// "we could not ask".
 25    private(set) var deps: DepsStatus?
 26    private(set) var depsError: String?
 27
 28    /// `repo access list`, with the same nil-plus-error shape as `deps`:
 29    /// "not loaded" and "could not ask" must not read as "nobody granted".
 30    private(set) var grants: [AccessGrant]?
 31    private(set) var grantsError: String?
 32
 33    /// Branch names from `repo refs`, for the default-branch picker.
 34    private(set) var branches: [String] = []
 35
 36    private let client: GitbayClient
 37    let repoPath: String
 38
 39    init(client: GitbayClient, repoPath: String) {
 40        self.client = client
 41        self.repoPath = repoPath
 42    }
 43
 44    func load() async {
 45        do {
 46            async let settings = client.read(
 47                ["repo", "settings", "show", repoPath], as: RepoSettings.self)
 48            async let detail = client.read(["repo", "show", repoPath], as: RepoDetail.self)
 49            state = .loaded(Loaded(settings: try await settings, detail: try await detail))
 50        } catch {
 51            state = .from(error)
 52        }
 53    }
 54
 55    /// `repo deps status` — three words, unlike every other `repo` command
 56    /// in this file, which is exactly why it's easy to get wrong.
 57    func loadDeps() async {
 58        depsError = nil
 59        deps = nil
 60        do {
 61            deps = try await client.read(["repo", "deps", "status", repoPath], as: DepsStatus.self)
 62        } catch let error as GitbayError {
 63            depsError = error.userFacingMessage
 64        } catch {
 65            depsError = GitbayError.transport(error).userFacingMessage
 66        }
 67    }
 68
 69    /// `enable`/`disable` are two distinct commands, not one command with a
 70    /// flag. Reloads the status afterward so the report reflects the
 71    /// change; a refused write leaves `deps` untouched.
 72    func setDepsEnabled(_ on: Bool) async {
 73        await perform(["repo", "deps", on ? "enable" : "disable", repoPath], reload: loadDeps)
 74    }
 75
 76    // MARK: - Writes, one command per knob
 77
 78    func setDescription(_ text: String) async {
 79        await perform(["repo", "settings", "description", repoPath, text])
 80    }
 81
 82    func setWebsite(_ url: String) async {
 83        await perform(["repo", "settings", "website", repoPath, url])
 84    }
 85
 86    func setVisibility(_ visibility: String) async {
 87        await perform(["repo", "settings", "visibility", repoPath, visibility])
 88    }
 89
 90    func setGitDaemon(_ on: Bool) async {
 91        await perform(["repo", "settings", "git-daemon", repoPath, on ? "on" : "off"])
 92    }
 93
 94    func protectBranch(_ branch: String) async {
 95        await perform(["repo", "settings", "protect", repoPath, branch])
 96    }
 97
 98    func unprotectBranch(_ branch: String) async {
 99        await perform(["repo", "settings", "unprotect", repoPath, branch])
100    }
101
102    func setRequireApprovals(_ count: Int) async {
103        await perform(["repo", "settings", "require-approvals", repoPath, String(count)])
104    }
105
106    func setRequireResolved(_ on: Bool) async {
107        await perform(["repo", "settings", "require-resolved", repoPath, on ? "on" : "off"])
108    }
109
110    func setRequireChecks(_ on: Bool) async {
111        await perform(["repo", "settings", "require-checks", repoPath, on ? "on" : "off"])
112    }
113
114    /// `repo settings require-contexts` replaces the list, so the whole
115    /// list goes each time. Naming one turns the checks gate on.
116    /// Returns whether the field can be cleared: the server took it, or
117    /// it was already listed. A refused name stays in the field to fix.
118    @discardableResult
119    func addRequiredContext(_ context: String) async -> Bool {
120        let context = context.trimmingCharacters(in: .whitespaces)
121        let current = state.value?.settings.contexts ?? []
122        guard !context.isEmpty, !working else { return false }
123        guard !current.contains(context) else { return true }
124        await setRequiredContexts(current + [context])
125        return actionError == nil
126    }
127
128    /// Removing the last one leaves the gate as it was, waiting on every check.
129    func removeRequiredContext(_ context: String) async {
130        await setRequiredContexts((state.value?.settings.contexts ?? []).filter { $0 != context })
131    }
132
133    /// A check's name is typed, so the server's refusal of one is shown.
134    private func setRequiredContexts(_ contexts: [String]) async {
135        await perform(["repo", "settings", "require-contexts", repoPath] + contexts, typed: true) { await load() }
136    }
137
138    func setRequireSigned(_ on: Bool) async {
139        await perform(["repo", "settings", "require-signed", repoPath, on ? "on" : "off"])
140    }
141
142    func setRequireCodeowners(_ on: Bool) async {
143        await perform(["repo", "settings", "require-codeowners", repoPath, on ? "on" : "off"])
144    }
145
146    func setRequireMR(_ on: Bool) async {
147        await perform(["repo", "settings", "require-mr", repoPath, on ? "on" : "off"])
148    }
149
150    func protectTag(_ glob: String) async {
151        await perform(["repo", "settings", "protect-tag", repoPath, glob])
152    }
153
154    func unprotectTag(_ glob: String) async {
155        await perform(["repo", "settings", "unprotect-tag", repoPath, glob])
156    }
157
158    /// `repo settings default-branch`: moves HEAD and the record. The
159    /// server refuses a branch that does not exist, so the picker only
160    /// offers what `repo refs` listed.
161    func setDefaultBranch(_ branch: String) async {
162        await perform(["repo", "settings", "default-branch", repoPath, branch])
163    }
164
165    nonisolated private struct Renamed: Decodable, Sendable {
166        let repo: String
167    }
168
169    /// `repo rename <owner/name> <new-name>`: the row and the directory
170    /// move together and clone URLs change. Returns the new path; the
171    /// caller navigates there, since this screen's path is now gone.
172    func rename(to name: String) async -> String? {
173        let name = name.trimmingCharacters(in: .whitespaces)
174        guard !name.isEmpty else { return nil }
175        working = true
176        actionError = nil
177        defer { working = false }
178        do {
179            let renamed = try await client.run(["repo", "rename", repoPath, name], as: Renamed.self)
180            NotificationCenter.default.post(name: .gitbayRepositoryChanged, object: repoPath)
181            return renamed?.repo
182        } catch let error as GitbayError {
183            actionError = error.userFacingMessage
184        } catch {
185            actionError = GitbayError.transport(error).userFacingMessage
186        }
187        return nil
188    }
189
190    nonisolated private struct Transferred: Decodable, Sendable {
191        let repo: String
192    }
193
194    /// `repo transfer <owner/name> <new-owner>`: the repository moves to
195    /// another account or organization and its clone URLs change. Returns
196    /// the new path; this screen's is gone.
197    func transfer(to owner: String) async -> String? {
198        let owner = owner.trimmingCharacters(in: .whitespaces)
199        guard !owner.isEmpty else { return nil }
200        working = true
201        actionError = nil
202        defer { working = false }
203        do {
204            let moved = try await client.run(["repo", "transfer", repoPath, owner], as: Transferred.self)
205            NotificationCenter.default.post(name: .gitbayRepositoryChanged, object: repoPath)
206            return moved?.repo
207        } catch let error as GitbayError {
208            // The owner is typed: a refusal of it says what to fix.
209            actionError = error.messageForTypedInput
210        } catch {
211            actionError = GitbayError.transport(error).userFacingMessage
212        }
213        return nil
214    }
215
216    /// `repo delete <owner/name> --yes`. The screen asks for the path to
217    /// be typed first, as the web does; --yes is that confirmation.
218    func delete() async -> Bool {
219        working = true
220        actionError = nil
221        defer { working = false }
222        do {
223            try await client.run(["repo", "delete", repoPath, "--yes"])
224            NotificationCenter.default.post(name: .gitbayRepositoryChanged, object: repoPath)
225            return true
226        } catch GitbayError.notFound {
227            // The client retries a failure once. A delete that removed the
228            // row and then failed cleaning up answers the retry with not
229            // found: the repository is gone either way.
230            NotificationCenter.default.post(name: .gitbayRepositoryChanged, object: repoPath)
231            return true
232        } catch let error as GitbayError {
233            actionError = error.userFacingMessage
234        } catch {
235            actionError = GitbayError.transport(error).userFacingMessage
236        }
237        return false
238    }
239
240    func loadBranches() async {
241        let refs = try? await client.read(["repo", "refs", repoPath], as: RepoRefs.self)
242        branches = refs?.branches.map(\.name) ?? []
243    }
244
245    func loadGrants() async {
246        grantsError = nil
247        grants = nil
248        do {
249            grants = try await client.readList(["repo", "access", "list", repoPath], of: AccessGrant.self)
250        } catch let error as GitbayError {
251            grantsError = error.userFacingMessage
252        } catch {
253            grantsError = GitbayError.transport(error).userFacingMessage
254        }
255    }
256
257    /// `repo access grant <repo> <user> read|write|admin` — granting again
258    /// changes an existing user's role.
259    func grant(user: String, role: String) async {
260        let user = user.trimmingCharacters(in: .whitespaces)
261        guard !user.isEmpty else { return }
262        await perform(["repo", "access", "grant", repoPath, user, role], reload: loadGrants)
263    }
264
265    func revoke(user: String) async {
266        await perform(["repo", "access", "revoke", repoPath, user], reload: loadGrants)
267    }
268
269    func addTopic(_ topic: String) async {
270        await perform(["repo", "topics", "add", repoPath, topic])
271    }
272
273    func removeTopic(_ topic: String) async {
274        await perform(["repo", "topics", "remove", repoPath, topic])
275    }
276
277    private func perform(_ argv: [String]) async {
278        await perform(argv, reload: load)
279    }
280
281    private func perform(_ argv: [String], typed: Bool = false, reload: () async -> Void) async {
282        working = true
283        actionError = nil
284        defer { working = false }
285        do {
286            try await client.run(argv)
287            await reload()
288        } catch let error as GitbayError {
289            actionError = typed ? error.messageForTypedInput : error.userFacingMessage
290        } catch {
291            actionError = GitbayError.transport(error).userFacingMessage
292        }
293    }
294}