apps/web/app/routes/repo/settings-branches.tsx · flagon-io/g1t

1

import { ChevronRight, Scale, ShieldCheck } from "lucide-react";

2

import { Suspense } from "react";

3

import { Await, Form, Link } from "react-router";

4

5

import type { CommitMessageDefault } from "@g1t/contracts";

6

7

import { allowedMethods, isMergeMethod } from "../../lib/merge";

8

import { ruleInfo } from "../../lib/rules";

9

10

import type { Route } from "./+types/settings-branches";

11

import { page } from "../../lib/meta";

12

import { AddCiPrompt } from "../../components/add-ci";

13

import { CodeownersReportPanel, CodeownersReportSkeleton } from "../../components/codeowners";

14

import { RepoSettingsHeading } from "../../components/repo-settings-heading";

15

import { MergeMethodSettings } from "../../components/merge-settings";

16

import { EnforcementBadge } from "../../components/rules";

17

import { SettingsSection as Section, SettingToggle as Toggle } from "../../components/settings-section";

18

import { ErrorText, SubmitButton, TimeAgo } from "../../components/ui";

19

import { actions, repos, work } from "../../lib/services.server";

20

import { assertSameOrigin, getViewer, requireUser, unwrap } from "../../lib/session.server";

21

import { requireCapability, requireInsider } from "../../lib/access.server";

22

import { Unavailable } from "../../components/boundary";

23

import { isFailed, part } from "../../lib/partial";

24

25

const COMMIT_MESSAGE_DEFAULTS: CommitMessageDefault[] = [

26

"default",

27

"pull_title",

28

"pull_title_and_description",

29

"pull_title_and_commits",

"custom",

];

export function meta({ params, ...args }: Route.MetaArgs) {

34

return page(args, { title: `Branches and merging · ${params.owner}/${params.repo} · g1t` });

35

}

36

37

export async function loader({ params, context }: Route.LoaderArgs) {

38

const viewer = getViewer(context);

39

// Maintain and up: it shows the rules and changes only how ready pull requests merge; to anyone without a role here the page does not exist.

40

const { access } = await requireInsider(context, params, "manage_settings");

41

const path = { namespace: params.owner, name: params.repo };

42

const [repo, settings, seen, workflows] = await Promise.all([

43

repos.get(path, viewer),

44

work.getSettings(path, viewer),

45

// Only for offering to add CI: when either cannot be read, it is not offered.

46

part(work.seenChecks(path, viewer), "Checks seen"),

47

part(actions.workflows(path, viewer), "Workflows"),

48

]);

49

const found = unwrap(repo);

50

// What holds for the default branch: shown here, changed in Rules. A

51

// failure says so in its place: read as no rules, it would say the

52

// branch is unprotected.

53

const effective = await part(work.effectiveRules(path, found.defaultBranch, viewer), `The rules for ${found.defaultBranch}`);

54

// Streamed: the CODEOWNERS file is read and checked on its own time.

55

const codeowners = work

56

.codeownersErrors(path, viewer)

57

.then((report) => (report.ok ? report.value : null))

.catch(() => null);

return {

codeowners,

repo: found,

settings: unwrap(settings),

63

effective: isFailed(effective) ? effective : effective.ok ? effective.value : null,

64

// Nothing to require until something runs: the page offers to add CI.

65

noChecks: !isFailed(workflows) && workflows.ok && workflows.value.length === 0 && !isFailed(seen) && seen.ok && seen.value.length === 0,

66

canPush: access.can.push,

};

}

export async function action({ request, params, context }: Route.ActionArgs) {

71

assertSameOrigin(request);

72

const user = requireUser(context, request);

73

await requireCapability(context, params, "manage_settings");

74

const form = await request.formData();

75

const path = { namespace: params.owner, name: params.repo };

76

const on = (name: string) => form.get(name) === "on";

77

// Branch protection is the repository's rulesets' (Settings → Rules):

78

// what it holds is sent back as it is, so only how pull requests merge

79

// changes here.

80

const current = await work.getSettings(path, user);

81

if (!current.ok) return { saved: false, error: current.error.message };

82

const choice = (name: string, fallback: CommitMessageDefault): CommitMessageDefault => {

83

const value = form.get(name);

84

return typeof value === "string" && COMMIT_MESSAGE_DEFAULTS.includes(value as CommitMessageDefault) ? (value as CommitMessageDefault) : fallback;

85

};

86

// A template is posted only while it is shown; otherwise the saved one stays.

87

const template = (name: string, fallback: string | null) =>

88

form.has(name) ? String(form.get(name) ?? "").trim() || null : fallback;

89

const allowed = {

90

allowMergeCommit: on("allowMergeCommit"),

91

allowSquashMerge: on("allowSquashMerge"),

92

allowRebaseMerge: on("allowRebaseMerge"),

93

allowFastForward: on("allowFastForward"),

94

};

95

if (!Object.values(allowed).some(Boolean)) return { saved: false, error: "Allow at least one merge method." };

96

const asked = form.get("defaultMergeMethod");

97

const methods = allowedMethods(allowed);

98

const settings = await work.updateSettings(user, path, {

99

...current.value,

100

...allowed,

101

defaultMergeMethod: isMergeMethod(asked) && methods.includes(asked) ? asked : methods[0]!,

102

mergeCommitMessage: choice("mergeCommitMessage", current.value.mergeCommitMessage),

103

squashCommitMessage: choice("squashCommitMessage", current.value.squashCommitMessage),

104

mergeCommitTemplate: template("mergeCommitTemplate", current.value.mergeCommitTemplate),

105

squashCommitTemplate: template("squashCommitTemplate", current.value.squashCommitTemplate),

106

suggestUpdatingBranches: on("suggestUpdatingBranches"),

107

allowAutoMerge: on("allowAutoMerge"),

108

autoMerge: on("autoMerge"),

109

deleteBranchOnMerge: on("deleteBranchOnMerge"),

110

});

111

return settings.ok ? { saved: true, error: null } : { saved: false, error: settings.error.message };

112

}

113

114

export default function BranchSettings({ loaderData, actionData }: Route.ComponentProps) {

115

const { repo, settings, effective, noChecks, canPush, codeowners } = loaderData;

116

const branch = repo.defaultBranch;

117

const base = `/${repo.namespace}/${repo.name}`;

118

const archived = Boolean(repo.archivedAt);

119

const rules = isFailed(effective) ? null : effective;

120

const active = rules?.rules.filter((rule) => rule.enforcement === "active") ?? [];

121

const labels = [...new Set(active.map((rule) => ruleInfo(rule.type)?.label ?? rule.type))];

return (

<>

{/* Its own form, so outside the settings one. */}

{noChecks && (

</div>

)}

<Section

title="Branch protection"

134

about={`What holds for ${branch} and every other branch is set by rulesets, across the workspace.`}

135

>

136

<Link

137

to={`${base}/settings/rules`}

138

className="group flex items-start gap-3 rounded-xl border border-line p-4 transition-colors hover:border-line-strong hover:bg-surface"

>

<span className="block text-sm font-medium">Rules for {branch}</span>

143

{!isFailed(effective) && (

144

145

{labels.length > 0 ? labels.join(" · ") : `No active rules hold for ${branch}: anyone who may push can change it.`}

146

</span>

147

)}

148

{rules && rules.rulesets.length > 0 && (

149

150

{rules.rulesets.map((ruleset) => (

151

152

{ruleset.name} <EnforcementBadge enforcement={ruleset.enforcement} />

</span>

))}

</span>

)}

</span>

</Link>

{isFailed(effective) && <Unavailable what={effective.what} compact />}

161

<Link

162

to={`${base}/settings/guardrails`}

163

className="group flex items-center gap-3 rounded-xl border border-line p-4 transition-colors hover:border-line-strong hover:bg-surface"

>

<span className="block text-sm font-medium">Guardrails</span>

168

<span className="mt-0.5 block text-sm text-muted">How long this repository's runs may take.</span>

</span>

</Link>

</Section>

<Section

id="codeowners"

title="CODEOWNERS"

about={`Who owns which files, read from ${branch}. Owners are asked to review changes to their files.`}

>

{(report) => <CodeownersReportPanel report={report} base={base} branch={branch} />}

</Await>

</Suspense>

</Section>

<Section

id="merge-methods"

title="Merge methods"

191

about="How pull requests may land on their base branch. At least one stays on; a ruleset can narrow them for some branches."

>

</Section>

Whenever a pull request's base has commits its branch does not, offer to bring the branch up to date, with

199

a merge commit or a rebase, even when nothing requires it. Off, the offer shows only when a rule requires

200

pull requests to be up to date.

</Toggle>

</Section>

Whoever may merge a pull request can turn on auto-merge for it with the method and message they choose:

207

it merges, as them, the moment its required reviews and checks pass.

208

</Toggle>

209

210

A pull request g1t is seeing through for a work item lands without anyone pressing merge once every rule of

211

its branch is met, its required checks included. A ruleset can turn this off for some branches. Off, it

212

waits for a member to merge it.

</Toggle>

</Section>

A pull request's branch is deleted once it merges. Whoever merges can keep it that time, and a deleted

219

branch can be restored from its pull request.

</Toggle>

</Section>

Save settings

</SubmitButton>

{actionData?.saved && <span className="text-sm text-muted">Saved.</span>}

228

<ErrorText>{actionData?.error}</ErrorText>

229

{settings.updatedBy && settings.updatedAt && !actionData && (

230

231

Last changed by <span className="font-mono">{settings.updatedBy}</span> <TimeAgo at={settings.updatedAt} />

</span>

)}

</div>

</fieldset>

</Form>

</div>

</>

);

}