@magland/mochi 0.3.1

package/dist/pullweb.js

@@ -0,0 +1,461 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPulls = registerPulls;
+const avatar_1 = require("./avatar");
+const trigger_1 = require("./ci/trigger");
+const diff_1 = require("./diff");
+const git_1 = require("./git");
+const html_1 = require("./html");
+const icons_1 = require("./icons");
+const markdown_1 = require("./markdown");
+const ops_1 = require("./ops");
+const pulls = __importStar(require("./pulls"));
+const render_1 = require("./render");
+const session_1 = require("./session");
+const views_1 = require("./views");
+const web_1 = require("./web");
+// Pull requests: the pages over the store in pulls.ts, and the merge button
+// over ops.mergeBranch.
+//
+// A pull request here is one repository's branch proposed into another of its
+// branches. Across repositories comes with forking, and nothing in the stored
+// shape forbids it later; what it needs is a way to name a head somewhere
+// else, which a vault does not have yet.
+//
+// Who may do what follows the vault's model, as issues do: reading is
+// anonymous, opening one and commenting need a session, closing needs push
+// role or authorship, and merging needs the write role on the repository,
+// because a merge is a write to a branch like any other.
+// Descriptions and comments are the long fields here, as they are on an issue.
+const form = (0, web_1.urlencodedForm)('3mb');
+function pullsUrl(ctx) {
+    return `${(0, views_1.repoUrl)(ctx)}/pulls`;
+}
+/** Descriptions and comments are markdown, through the same sanitizing path
+ * as a README, with #12 and commit ids linked as they are in an issue. */
+function body(ctx, text) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const ref = (0, views_1.encPath)(ctx.defaultBranch || ctx.ref || 'HEAD');
+    return (0, html_1.raw)((0, markdown_1.renderMarkdown)(text, {
+        rawBase: `${base}/raw/${ref}`,
+        blobBase: `${base}/blob/${ref}`,
+        issueBase: `${base}/issues`,
+        commitBase: `${base}/commit`,
+    }));
+}
+function stateBadge(state) {
+    if (state === 'merged')
+        return (0, html_1.html) `<span class="state-badge merged">${(0, icons_1.icon)('git-merge')}<span>Merged</span></span>`;
+    if (state === 'closed')
+        return (0, html_1.html) `<span class="state-badge closed">${(0, icons_1.icon)('git-pull-request-closed')}<span>Closed</span></span>`;
+    return (0, html_1.html) `<span class="state-badge open">${(0, icons_1.icon)('git-pull-request')}<span>Open</span></span>`;
+}
+function stateIcon(state) {
+    if (state === 'merged')
+        return (0, icons_1.icon)('git-merge', 'pull-merged');
+    if (state === 'closed')
+        return (0, icons_1.icon)('git-pull-request-closed', 'issue-closed');
+    return (0, icons_1.icon)('git-pull-request', 'issue-open');
+}
+function branchPair(ctx, pull) {
+    const base = (0, views_1.repoUrl)(ctx);
+    const chip = (ref) => (0, html_1.html) `<a class="chip mono" href="${base}/tree/${(0, views_1.encPath)(ref)}">${ref}</a>`;
+    return (0, html_1.html) `${chip(pull.base)} <span class="muted">&larr;</span> ${chip(pull.head)}`;
+}
+function listPage(ctx, list, state, counts) {
+    const base = pullsUrl(ctx);
+    const tab = (id, label, n, glyph) => (0, html_1.html) `<a class="state-tab${state === id ? ' current' : ''}" href="${base}?state=${id}">${(0, icons_1.icon)(glyph)}<span>${n} ${label}</span></a>`;
+    const rows = list.map((p) => (0, html_1.html) `<tr>
+<td class="issue-cell">${stateIcon(p.state)}<span>
+<a class="issue-link" href="${base}/${p.number}">${p.title}</a>
+<div class="muted small">#${p.number} opened ${(0, render_1.timeTag)(p.created)} by ${p.author} &middot; ${branchPair(ctx, p)}</div></span></td>
+<td class="right muted small">${p.comments > 0
+        ? (0, html_1.html) `<a class="issue-comments" href="${base}/${p.number}" title="${p.comments} comment${p.comments === 1 ? '' : 's'}">${(0, icons_1.icon)('comment')}<span>${p.comments}</span></a>`
+        : ''}</td>
+</tr>`);
+    const newBtn = ctx.viewer
+        ? (0, html_1.html) `<a class="btn btn-primary" href="${base}/new">${(0, icons_1.icon)('git-pull-request')}<span>New pull request</span></a>`
+        : (0, html_1.html) `<a class="btn" href="/login?next=${encodeURIComponent(`${base}/new`)}">${(0, icons_1.icon)('git-pull-request')}<span>New pull request</span></a>`;
+    const empty = state === 'closed'
+        ? 'Nothing closed or merged yet.'
+        : state === 'open'
+            ? 'No open pull requests. Push a branch and propose it here.'
+            : 'No pull requests yet.';
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'pulls')}
+<div class="page-head">
+  <span class="state-filter">${tab('open', 'Open', counts.open, 'git-pull-request')}${tab('closed', 'Closed', counts.closed, 'git-merge')}</span>
+  ${newBtn}
+</div>
+${rows.length
+        ? (0, html_1.html) `<table class="listing issues"><tbody>${rows}</tbody></table>`
+        : (0, html_1.html) `<div class="empty-state">${empty}</div>`}`;
+    return (0, views_1.layout)(`Pull requests - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, base));
+}
+function commentCard(author, when, rendered, note = '') {
+    return (0, html_1.html) `<article class="issue-comment">
+<div class="issue-comment-head">${(0, avatar_1.avatar)(author, 24)}<b>${author}</b><span class="muted small">${note || 'commented'} ${(0, render_1.timeTag)(when)}</span></div>
+<div class="issue-comment-body markdown-body">${rendered}</div>
+</article>`;
+}
+/** The box that says whether this can be merged, and offers to do it. */
+function mergeBox(ctx, pull, preview, canMerge) {
+    const viewer = ctx.viewer;
+    if (pull.state === 'merged') {
+        // A merged branch has done its work; GitHub offers to sweep it away here
+        // and so does this, for anyone who may push and for any branch but the
+        // one it was merged into.
+        const stale = ctx.branches.some((b) => b.name === pull.head) && pull.head !== ctx.defaultBranch;
+        const sweep = stale && ctx.canPush && viewer
+            ? (0, html_1.html) `<form method="post" action="${pullsUrl(ctx)}/${pull.number}/delete-branch" data-confirm="Delete the branch ${pull.head}?">${(0, views_1.csrfField)(viewer)}<button class="btn" type="submit">${(0, icons_1.icon)('trash')}<span>Delete branch ${pull.head}</span></button></form>`
+            : '';
+        return (0, html_1.html) `<div class="merge-box merged">${(0, icons_1.icon)('git-merge')}<div><b>Merged</b><div class="muted small">${pull.mergedBy ?? 'someone'} merged this ${pull.mergedAt ? (0, render_1.timeTag)(pull.mergedAt) : ''}${pull.mergeSha
+            ? (0, html_1.html) ` as <a class="sha" href="${(0, views_1.repoUrl)(ctx)}/commit/${pull.mergeSha}">${pull.mergeSha.slice(0, 7)}</a>`
+            : ''}</div></div>${sweep}</div>`;
+    }
+    if (pull.state === 'closed') {
+        return (0, html_1.html) `<div class="merge-box closed">${(0, icons_1.icon)('git-pull-request-closed')}<div><b>Closed without merging</b><div class="muted small">${pull.closedBy ?? 'someone'} closed this ${pull.closedAt ? (0, render_1.timeTag)(pull.closedAt) : ''}</div></div></div>`;
+    }
+    if (!preview) {
+        return (0, html_1.html) `<div class="merge-box unknown">${(0, icons_1.icon)('alert')}<div><b>This branch cannot be compared</b><div class="muted small">One of ${pull.base} and ${pull.head} no longer exists.</div></div></div>`;
+    }
+    if (preview.status === 'up-to-date') {
+        return (0, html_1.html) `<div class="merge-box unknown">${(0, icons_1.icon)('check')}<div><b>Nothing to merge</b><div class="muted small">${pull.base} already contains everything on ${pull.head}.</div></div></div>`;
+    }
+    if (preview.status === 'conflict') {
+        const paths = preview.paths.slice(0, 20).map((p) => (0, html_1.html) `<li class="mono">${p}</li>`);
+        return (0, html_1.html) `<div class="merge-box conflict">${(0, icons_1.icon)('x')}<div><b>This branch has conflicts that must be resolved</b>
+<div class="muted small">Merge ${pull.base} into ${pull.head} where you work, resolve them, and push.</div>
+<ul class="merge-conflicts">${paths}</ul></div></div>`;
+    }
+    // How to merge is a choice, as it is on GitHub: keep both parents and the
+    // shape of the branch, or land it as one commit.
+    const button = canMerge && viewer
+        ? (0, html_1.html) `<form class="merge-do" method="post" action="${pullsUrl(ctx)}/${pull.number}/merge">${(0, views_1.csrfField)(viewer)}
+<label class="merge-method"><select name="method"><option value="merge">Merge commit</option><option value="squash">Squash and merge</option></select></label>
+<button class="btn btn-primary" type="submit">${(0, icons_1.icon)('git-merge')}<span>Merge pull request</span></button></form>`
+        : (0, html_1.html) `<span class="muted small">${viewer ? 'Merging needs push access to this repository.' : 'Sign in with push access to merge.'}</span>`;
+    return (0, html_1.html) `<div class="merge-box clean">${(0, icons_1.icon)('check')}<div><b>This branch has no conflicts with ${pull.base}</b><div class="muted small">${preview.fastForward
+        ? 'It can be merged by moving the branch forward.'
+        : 'Merging creates a merge commit on the base branch.'}</div></div>${button}</div>`;
+}
+function pullPage(ctx, pull, view) {
+    const base = pullsUrl(ctx);
+    const repo = (0, views_1.repoUrl)(ctx);
+    const viewer = ctx.viewer;
+    const mine = viewer !== null && viewer.auth.username === pull.author;
+    const canClose = ctx.canPush || mine;
+    const comments = pull.commentList.map((c) => commentCard(c.author, c.created, body(ctx, c.body)));
+    let replyBox;
+    if (viewer) {
+        const toggle = canClose && pull.state !== 'merged'
+            ? (0, html_1.html) `<button class="btn" type="submit" name="state" value="${pull.state === 'open' ? 'closed' : 'open'}" formaction="${base}/${pull.number}/state">${(0, icons_1.icon)(pull.state === 'open' ? 'git-pull-request-closed' : 'git-pull-request')}<span>${pull.state === 'open' ? 'Close pull request' : 'Reopen'}</span></button>`
+            : '';
+        replyBox = (0, html_1.html) `<form class="issue-reply" method="post" action="${base}/${pull.number}/comment">${(0, views_1.csrfField)(viewer)}
+<div class="issue-comment-head">${(0, avatar_1.avatar)(viewer.auth.username, 24)}<b>${viewer.auth.username}</b></div>
+<textarea class="code-editor" name="body" rows="6" placeholder="Leave a comment"></textarea>
+<div class="actions">${toggle}<button class="btn btn-primary" type="submit">Comment</button></div>
+</form>`;
+    }
+    else {
+        replyBox = (0, html_1.html) `<p class="muted"><a href="/login?next=${encodeURIComponent(`${base}/${pull.number}`)}">Sign in</a> to comment.</p>`;
+    }
+    const commitRows = view.commits.map((c) => (0, html_1.html) `<div class="commit-row"><span class="commit-main"><a class="title" href="${repo}/commit/${c.sha}">${c.subject}</a><div class="muted small">${c.author} committed ${(0, render_1.timeTag)(c.date)}</div></span><a class="sha" href="${repo}/commit/${c.sha}">${c.sha.slice(0, 7)}</a></div>`);
+    const description = body(ctx, pull.body);
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'pulls')}
+<div class="issue-head">
+  <h1 class="issue-title">${pull.title} <span class="muted">#${pull.number}</span></h1>
+  <span class="right-group"><a class="btn" href="${base}">Back to pull requests</a></span>
+</div>
+<div class="issue-sub">${stateBadge(pull.state)}<span class="muted"><b>${pull.author}</b> wants to merge ${view.ahead} commit${view.ahead === 1 ? '' : 's'} into </span>${branchPair(ctx, pull)}</div>
+${mergeBox(ctx, pull, view.preview, ctx.canPush)}
+<div class="issue-thread">
+${commentCard(pull.author, pull.created, description.text ? description : (0, html_1.raw)('<p class="muted">No description.</p>'), 'opened this')}
+${comments}
+${replyBox}
+</div>
+<div class="box"><div class="box-header">${(0, icons_1.icon)('git-commit')}<span>${view.commits.length} commit${view.commits.length === 1 ? '' : 's'}</span></div><div class="box-body pull-commits">${commitRows.length ? commitRows : (0, html_1.raw)('<p class="muted">Nothing to merge.</p>')}</div></div>
+<h2 class="pull-files">Files changed</h2>
+${(0, html_1.raw)((0, diff_1.renderDiff)(view.patch, { blobBase: `${repo}/blob/${(0, views_1.encPath)(pull.head)}` }))}`;
+    return (0, views_1.layout)(`${pull.title} · #${pull.number} - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${base}/${pull.number}`));
+}
+function newPage(ctx, viewer, values, info, error) {
+    const base = pullsUrl(ctx);
+    const options = (selected) => ctx.branches.map((b) => (0, html_1.html) `<option value="${b.name}"${b.name === selected ? (0, html_1.raw)(' selected') : ''}>${b.name}</option>`);
+    const content = (0, html_1.html) `${(0, views_1.repoHeader)(ctx, 'pulls')}
+<div class="form-box wide">
+<h1>New pull request</h1>
+${error ? (0, html_1.html) `<div class="form-error">${error}</div>` : ''}
+<form method="get" action="${base}/new" class="cmp-form">
+${(0, icons_1.icon)('git-compare')}<label class="cmp-picker">base <select name="base">${options(values.base)}</select></label>
+<span class="muted">&larr;</span>
+<label class="cmp-picker">compare <select name="head">${options(values.head)}</select></label>
+<button class="btn" type="submit">Change branches</button>
+</form>
+${info
+        ? (0, html_1.html) `<p class="muted">${info.ahead} commit${info.ahead === 1 ? '' : 's'} would be merged into <b>${values.base}</b> from <b>${values.head}</b>.</p>`
+        : ''}
+<form method="post" action="${base}/new">${(0, views_1.csrfField)(viewer)}
+<input type="hidden" name="base" value="${values.base}">
+<input type="hidden" name="head" value="${values.head}">
+<div class="field"><label for="title">Title</label>
+<input type="text" id="title" name="title" value="${values.title}" maxlength="${pulls.MAX_TITLE}" required autofocus></div>
+<div class="field"><label for="body">Description</label>
+<textarea class="code-editor" id="body" name="body" rows="10" placeholder="What this changes, and why. Markdown is welcome.">${values.body}</textarea></div>
+<div class="actions"><button class="btn btn-primary" type="submit">${(0, icons_1.icon)('git-pull-request')}<span>Create pull request</span></button><a class="btn" href="${base}">Cancel</a></div>
+</form>
+</div>`;
+    return (0, views_1.layout)(`New pull request - ${ctx.collection}/${ctx.repo}`, content, (0, views_1.repoOpts)(ctx, `${base}/new`));
+}
+function registerPulls(app, root, engine) {
+    /** The repository context plus the pull request named in the URL. */
+    async function withPull(req, res, viewer) {
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return null;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        if (!/^[1-9][0-9]*$/.test(req.params.n ?? '')) {
+            (0, web_1.send404)(res, 'No such pull request', viewer);
+            return null;
+        }
+        const n = parseInt(req.params.n, 10);
+        const pull = pulls.readPull(root, ctx.collection, ctx.repo, n);
+        if (!pull) {
+            (0, web_1.send404)(res, `Pull request #${n} does not exist in ${ctx.collection}/${ctx.repo}`, viewer);
+            return null;
+        }
+        return { ctx, pull, loaded };
+    }
+    app.get('/:collection/:repo/pulls', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        const asked = String(req.query.state ?? 'open');
+        const state = asked === 'closed' ? 'closed' : asked === 'all' ? 'all' : 'open';
+        const all = pulls.listPulls(root, ctx.collection, ctx.repo);
+        const counts = {
+            open: all.filter((p) => p.state === 'open').length,
+            closed: all.filter((p) => p.state !== 'open').length,
+        };
+        const list = state === 'all' ? all : all.filter((p) => (state === 'open' ? p.state === 'open' : p.state !== 'open'));
+        res.type('html').send(listPage(ctx, list, state, counts));
+    }));
+    app.get('/:collection/:repo/pulls/new', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPage)(root, req, res);
+        if (!viewer)
+            return;
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        const names = ctx.branches.map((b) => b.name);
+        const asked = (name, fallback) => {
+            const value = String(req.query[name] ?? '');
+            return names.includes(value) ? value : fallback;
+        };
+        const baseRef = asked('base', ctx.defaultBranch || names[0] || '');
+        const headRef = asked('head', names.find((n) => n !== baseRef) ?? baseRef);
+        if (names.length < 2) {
+            (0, web_1.fail)(res, 400, 'A pull request needs two branches; this repository has fewer.', viewer, (0, views_1.repoUrl)(ctx));
+            return;
+        }
+        const cmp = await loaded.repo.compare(baseRef, headRef);
+        res.type('html').send(newPage(ctx, viewer, {
+            base: baseRef,
+            head: headRef,
+            // The first commit's subject is what people would type anyway.
+            title: cmp.commits.length === 1 ? cmp.commits[0].subject : '',
+            body: '',
+        }, { ahead: cmp.ahead, commits: cmp.commits }));
+    }));
+    app.post('/:collection/:repo/pulls/new', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const loaded = await (0, web_1.loadRepo)(root, req, res, viewer);
+        if (!loaded)
+            return;
+        const ctx = await (0, web_1.makeCtx)(root, req, loaded, loaded.defaultBranch ?? '', viewer);
+        const baseRef = (0, web_1.field)(req, 'base');
+        const headRef = (0, web_1.field)(req, 'head');
+        const title = (0, web_1.field)(req, 'title');
+        const text = (0, web_1.field)(req, 'body');
+        try {
+            const created = pulls.openPull(root, ctx.collection, ctx.repo, { title, body: text, author: viewer.auth.username, base: baseRef, head: headRef }, ctx.branches.map((b) => b.name));
+            res.redirect(`${pullsUrl(ctx)}/${created.number}`);
+        }
+        catch (e) {
+            const message = e instanceof ops_1.OpError ? e.message : 'Could not open the pull request.';
+            res
+                .status(400)
+                .type('html')
+                .send(newPage(ctx, viewer, { base: baseRef, head: headRef, title, body: text }, null, message));
+        }
+    }));
+    app.get('/:collection/:repo/pulls/:n', (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, session_1.getViewer)(req, root);
+        const found = await withPull(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, pull, loaded } = found;
+        const known = (ref) => ctx.branches.some((b) => b.name === ref);
+        let view = { commits: [], patch: '', ahead: 0, preview: null };
+        if ((0, git_1.isValidRefName)(pull.base) && (0, git_1.isValidRefName)(pull.head) && known(pull.base) && known(pull.head)) {
+            const cmp = await loaded.repo.compare(pull.base, pull.head);
+            // A merged or closed pull request is history: what it did is on the
+            // base branch already, so no merge is planned for it.
+            const preview = pull.state === 'open' ? await (0, ops_1.previewMerge)(loaded.repo.dir, pull.base, pull.head).catch(() => null) : null;
+            view = { commits: cmp.commits, patch: cmp.patch, ahead: cmp.ahead, preview };
+        }
+        res.type('html').send(pullPage(ctx, pull, view));
+    }));
+    app.post('/:collection/:repo/pulls/:n/comment', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withPull(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, pull } = found;
+        try {
+            pulls.addComment(root, ctx.collection, ctx.repo, pull.number, {
+                author: viewer.auth.username,
+                body: (0, web_1.field)(req, 'body'),
+            });
+        }
+        catch (e) {
+            (0, web_1.fail)(res, 400, e instanceof ops_1.OpError ? e.message : 'Could not add the comment.', viewer, `${pullsUrl(ctx)}/${pull.number}`);
+            return;
+        }
+        res.redirect(`${pullsUrl(ctx)}/${pull.number}`);
+    }));
+    app.post('/:collection/:repo/pulls/:n/state', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withPull(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, pull } = found;
+        if (!ctx.canPush && viewer.auth.username !== pull.author) {
+            (0, web_1.fail)(res, 403, 'Only the author or someone with push access can close this pull request.', viewer, `${pullsUrl(ctx)}/${pull.number}`);
+            return;
+        }
+        const state = (0, web_1.field)(req, 'state') === 'closed' ? 'closed' : 'open';
+        const text = (0, web_1.field)(req, 'body').trim();
+        if (text !== '') {
+            try {
+                pulls.addComment(root, ctx.collection, ctx.repo, pull.number, {
+                    author: viewer.auth.username,
+                    body: text,
+                });
+            }
+            catch (e) {
+                // As in the issue route: a comment the writer got wrong must not stop
+                // the state change, but a failure to write at all should surface.
+                if (!(e instanceof ops_1.OpError))
+                    throw e;
+            }
+        }
+        try {
+            pulls.setPullState(root, ctx.collection, ctx.repo, pull.number, state, viewer.auth.username);
+        }
+        catch (e) {
+            (0, web_1.fail)(res, 400, e instanceof ops_1.OpError ? e.message : 'Could not change the state.', viewer, `${pullsUrl(ctx)}/${pull.number}`);
+            return;
+        }
+        res.redirect(`${pullsUrl(ctx)}/${pull.number}`);
+    }));
+    app.post('/:collection/:repo/pulls/:n/delete-branch', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withPull(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, pull, loaded } = found;
+        const back = `${pullsUrl(ctx)}/${pull.number}`;
+        if (!ctx.canPush) {
+            (0, web_1.fail)(res, 403, `You do not have push access to ${ctx.collection}/${ctx.repo}.`, viewer, back);
+            return;
+        }
+        try {
+            await pulls.deletePullBranch(root, loaded.repo, pull.number, { defaultBranch: ctx.defaultBranch });
+        }
+        catch (e) {
+            (0, web_1.fail)(res, 400, e instanceof ops_1.OpError ? e.message : 'Could not delete the branch.', viewer, back);
+            return;
+        }
+        res.redirect(back);
+    }));
+    app.post('/:collection/:repo/pulls/:n/merge', form, (0, web_1.ah)(async (req, res) => {
+        const viewer = (0, web_1.requireViewerPost)(root, req, res);
+        if (!viewer)
+            return;
+        const found = await withPull(req, res, viewer);
+        if (!found)
+            return;
+        const { ctx, pull, loaded } = found;
+        const back = `${pullsUrl(ctx)}/${pull.number}`;
+        // Merging writes to a branch, so it takes the write role on the
+        // repository: authorship is not enough, as it is for closing.
+        if (!ctx.canPush) {
+            (0, web_1.fail)(res, 403, `You do not have push access to ${ctx.collection}/${ctx.repo}.`, viewer, back);
+            return;
+        }
+        if (pull.state !== 'open') {
+            (0, web_1.fail)(res, 400, 'This pull request is not open.', viewer, back);
+            return;
+        }
+        const method = (0, web_1.field)(req, 'method') === 'squash' ? 'squash' : 'merge';
+        const host = (req.get('host') ?? 'localhost').replace(/:\d+$/, '');
+        let result;
+        try {
+            result = await pulls.mergePull(root, loaded.repo, pull.number, { username: viewer.auth.username, email: `${viewer.auth.username}@noreply.${host}` }, { method }, { defaultBranch: ctx.defaultBranch });
+        }
+        catch (e) {
+            if (e instanceof pulls.MergeConflict) {
+                (0, web_1.fail)(res, 409, e.message, viewer, back);
+                return;
+            }
+            (0, web_1.fail)(res, 400, e instanceof ops_1.OpError ? e.message : 'The merge failed.', viewer, back);
+            return;
+        }
+        (0, trigger_1.firePush)(root, engine, { collection: ctx.collection, name: ctx.repo }, pull.base, result.before, result.sha, viewer.auth.username);
+        res.redirect(back);
+    }));
+}