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

23

const COMMIT_MESSAGE_DEFAULTS: CommitMessageDefault[] = [

24

"default",

25

"pull_title",

26

"pull_title_and_description",

27

"pull_title_and_commits",

"custom",

];

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

32

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

33

}

34

35

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

36

const viewer = getViewer(context);

37

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

38

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

39

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

40

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

41

repos.get(path, viewer),

42

work.getSettings(path, viewer),

43

work.seenChecks(path, viewer),

44

actions.workflows(path, viewer),

45

]);

46

const found = unwrap(repo);

47

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

48

const effective = await work.effectiveRules(path, found.defaultBranch, viewer).catch(() => null);

49

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

50

const codeowners = work

51

.codeownersErrors(path, viewer)

52

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

.catch(() => null);

return {

codeowners,

repo: found,

settings: unwrap(settings),

58

effective: effective?.ok ? effective.value : null,

59

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

60

noChecks: workflows.ok && workflows.value.length === 0 && seen.ok && seen.value.length === 0,

61

canPush: access.can.push,

};

}

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

66

assertSameOrigin(request);

67

const user = requireUser(context, request);

68

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

69

const form = await request.formData();

70

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

71

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

72

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

73

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

74

// changes here.

75

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

76

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

77

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

78

const value = form.get(name);

79

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

80

};

81

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

82

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

83

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

84

const allowed = {

85

allowMergeCommit: on("allowMergeCommit"),

86

allowSquashMerge: on("allowSquashMerge"),

87

allowRebaseMerge: on("allowRebaseMerge"),

88

allowFastForward: on("allowFastForward"),

89

};

90

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

91

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

92

const methods = allowedMethods(allowed);

93

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

94

...current.value,

95

...allowed,

96

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

97

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

98

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

99

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

100

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

101

suggestUpdatingBranches: on("suggestUpdatingBranches"),

102

allowAutoMerge: on("allowAutoMerge"),

103

autoMerge: on("autoMerge"),

104

deleteBranchOnMerge: on("deleteBranchOnMerge"),

105

});

106

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

107

}

108

109

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

110

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

111

const branch = repo.defaultBranch;

112

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

113

const archived = Boolean(repo.archivedAt);

114

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

115

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"

128

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

129

>

130

<Link

131

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

132

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>

137

138

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

139

</span>

140

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

141

142

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

143

144

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

</span>

))}

</span>

)}

</span>

</Link>

<Link

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

154

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>

159

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

182

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

190

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

191

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:

198

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

199

</Toggle>

200

201

A pull request g1t is seeing through for an issue lands without anyone pressing merge once every rule of

202

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

203

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

210

branch can be restored from its pull request.

</Toggle>

</Section>

Save settings

</SubmitButton>

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

219

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

220

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

221

222

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

</span>

)}

</div>

</fieldset>

</Form>

</div>

</>

);

}