@magland/mochi 0.3.1

package/dist/pulls.js

@@ -0,0 +1,320 @@
+"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.MergeConflict = exports.MAX_TITLE = exports.MAX_BODY = void 0;
+exports.pullsDir = pullsDir;
+exports.listPulls = listPulls;
+exports.pullCounts = pullCounts;
+exports.readPull = readPull;
+exports.createPull = createPull;
+exports.addComment = addComment;
+exports.setPullState = setPullState;
+exports.recordMerge = recordMerge;
+exports.editPull = editPull;
+exports.openPull = openPull;
+exports.defaultMergeMessage = defaultMergeMessage;
+exports.mergePull = mergePull;
+exports.deletePullBranch = deletePullBranch;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const discussion_1 = require("./discussion");
+const ops_1 = require("./ops");
+const layout_1 = require("./layout");
+const scan_1 = require("./scan");
+var discussion_2 = require("./discussion");
+Object.defineProperty(exports, "MAX_BODY", { enumerable: true, get: function () { return discussion_2.MAX_BODY; } });
+Object.defineProperty(exports, "MAX_TITLE", { enumerable: true, get: function () { return discussion_2.MAX_TITLE; } });
+/** The pulls directory for a repository, whether or not it exists yet. */
+function pullsDir(root, collection, repo) {
+    if (!(0, scan_1.isValidName)(collection) || !(0, scan_1.isValidName)(repo))
+        return null;
+    return (0, layout_1.repoPath)(root, collection, `${(0, scan_1.displayName)(repo)}.pulls`);
+}
+const PULL = {
+    doc: 'pull.md',
+    indefinite: 'a pull request',
+    Indefinite: 'A pull request',
+    Bare: 'Pull request',
+    dirFor: pullsDir,
+};
+function pullDir(root, collection, repo, n) {
+    return (0, discussion_1.itemDir)(PULL, root, collection, repo, n);
+}
+function stateOf(v) {
+    return v === 'closed' || v === 'merged' ? v : 'open';
+}
+function summaryFrom(n, dir, doc) {
+    const created = (0, discussion_1.str)(doc.meta.created);
+    const summary = {
+        number: n,
+        title: (0, discussion_1.str)(doc.meta.title, `Pull request ${n}`),
+        state: stateOf(doc.meta.state),
+        author: (0, discussion_1.str)(doc.meta.author, 'unknown'),
+        created,
+        updated: (0, discussion_1.str)(doc.meta.updated, created),
+        base: (0, discussion_1.str)(doc.meta.base),
+        head: (0, discussion_1.str)(doc.meta.head),
+        comments: (0, discussion_1.countComments)(dir),
+    };
+    for (const key of ['closedBy', 'closedAt', 'mergedBy', 'mergedAt', 'mergeSha']) {
+        const value = (0, discussion_1.str)(doc.meta[key]);
+        if (value)
+            summary[key] = value;
+    }
+    return summary;
+}
+function listPulls(root, collection, repo) {
+    const dir = pullsDir(root, collection, repo);
+    if (!dir)
+        return [];
+    const out = [];
+    for (const n of (0, discussion_1.numericDirs)(dir)) {
+        const sub = path.join(dir, String(n));
+        const doc = (0, discussion_1.readDoc)(path.join(sub, 'pull.md'));
+        if (doc)
+            out.push(summaryFrom(n, sub, doc));
+    }
+    return out.sort((a, b) => b.number - a.number);
+}
+// The tab counts open pull requests on every repository page, so the count is
+// memoized against the directory's mtime: every write here touches it.
+const countMemo = new Map();
+function pullCounts(root, collection, repo) {
+    const dir = pullsDir(root, collection, repo);
+    if (!dir)
+        return { open: 0, closed: 0 };
+    let mtimeMs;
+    try {
+        mtimeMs = fs.statSync(dir).mtimeMs;
+    }
+    catch {
+        return { open: 0, closed: 0 };
+    }
+    const hit = countMemo.get(dir);
+    if (hit && hit.mtimeMs === mtimeMs)
+        return hit.counts;
+    const counts = { open: 0, closed: 0 };
+    for (const pull of listPulls(root, collection, repo)) {
+        if (pull.state === 'open')
+            counts.open++;
+        else
+            counts.closed++;
+    }
+    countMemo.set(dir, { mtimeMs, counts });
+    return counts;
+}
+function readPull(root, collection, repo, n) {
+    const dir = pullDir(root, collection, repo, n);
+    if (!dir)
+        return null;
+    const doc = (0, discussion_1.readDoc)(path.join(dir, 'pull.md'));
+    if (!doc)
+        return null;
+    return { ...summaryFrom(n, dir, doc), body: doc.body, commentList: (0, discussion_1.readComments)(dir) };
+}
+function createPull(root, collection, repo, input) {
+    const dir = pullsDir(root, collection, repo);
+    if (!dir)
+        throw new ops_1.OpError('invalid collection or repository name');
+    const title = (0, discussion_1.checkTitle)(PULL, input.title);
+    const body = (0, discussion_1.checkBody)(PULL, input.body);
+    if (input.base === input.head)
+        throw new ops_1.OpError('A branch cannot be merged into itself.');
+    const now = new Date().toISOString();
+    const n = (0, discussion_1.allocate)(PULL, dir, (sub) => (0, discussion_1.writeDoc)(path.join(sub, 'pull.md'), {
+        title,
+        state: 'open',
+        author: input.author,
+        created: now,
+        updated: now,
+        base: input.base,
+        head: input.head,
+    }, body));
+    return {
+        number: n,
+        title,
+        state: 'open',
+        author: input.author,
+        created: now,
+        updated: now,
+        base: input.base,
+        head: input.head,
+        comments: 0,
+    };
+}
+function addComment(root, collection, repo, n, input) {
+    return (0, discussion_1.addComment)(PULL, root, collection, repo, n, input);
+}
+function setPullState(root, collection, repo, n, state, actor) {
+    const { dir, doc } = (0, discussion_1.openFor)(PULL, root, collection, repo, n);
+    if (stateOf(doc.meta.state) === 'merged')
+        throw new ops_1.OpError('A merged pull request cannot be reopened.');
+    const now = new Date().toISOString();
+    const meta = { ...doc.meta, state, updated: now };
+    if (state === 'closed') {
+        meta.closedBy = actor;
+        meta.closedAt = now;
+    }
+    else {
+        delete meta.closedBy;
+        delete meta.closedAt;
+    }
+    (0, discussion_1.writeDoc)(path.join(dir, 'pull.md'), meta, doc.body);
+    touchPulls(root, collection, repo);
+}
+/** Record that the merge happened; the merge itself is ops.mergeBranch. */
+function recordMerge(root, collection, repo, n, input) {
+    const { dir, doc } = (0, discussion_1.openFor)(PULL, root, collection, repo, n);
+    const now = new Date().toISOString();
+    (0, discussion_1.writeDoc)(path.join(dir, 'pull.md'), { ...doc.meta, state: 'merged', updated: now, mergedBy: input.actor, mergedAt: now, mergeSha: input.sha }, doc.body);
+    touchPulls(root, collection, repo);
+}
+function editPull(root, collection, repo, n, input) {
+    const { dir, doc } = (0, discussion_1.openFor)(PULL, root, collection, repo, n);
+    const meta = { ...doc.meta, updated: new Date().toISOString() };
+    if (input.title !== undefined)
+        meta.title = (0, discussion_1.checkTitle)(PULL, input.title);
+    const body = input.body === undefined ? doc.body : (0, discussion_1.checkBody)(PULL, input.body);
+    (0, discussion_1.writeDoc)(path.join(dir, 'pull.md'), meta, body);
+    touchPulls(root, collection, repo);
+}
+/** Move the pulls directory's timestamp, invalidating the count cache. */
+function touchPulls(root, collection, repo) {
+    const dir = pullsDir(root, collection, repo);
+    if (dir)
+        (0, discussion_1.touch)(dir);
+}
+// ---- the operations a transport performs, rather than the state it stores ----
+//
+// Opening and merging a pull request are each a sequence: validate against the
+// branches the repository really has, write the record, move a branch, write the
+// record again. Those sequences lived inside the web handlers, which made the web
+// the only place that could perform them correctly. They take plain values and
+// throw OpError, so the web handler and the API handler are transports over one
+// implementation rather than two implementations that ought to agree.
+//
+// The actor is the one thing the two transports genuinely disagree about: a
+// Viewer resolved from a session cookie on the web, an AuthResult from a bearer
+// token on the API. Both carry a username, so that is all these take.
+/**
+ * A merge refused because it does not apply. Separate from a plain OpError
+ * because the caller has something useful to say: which paths conflict.
+ */
+class MergeConflict extends ops_1.OpError {
+    paths;
+    constructor(paths) {
+        super('This branch has conflicts that must be resolved before it can be merged.', 'conflict');
+        this.paths = paths;
+    }
+}
+exports.MergeConflict = MergeConflict;
+/**
+ * Open a pull request, having checked that both refs are branches this
+ * repository actually has. The caller supplies the branch names because it has
+ * already listed them; asking git again here would be a second answer to a
+ * question already asked.
+ */
+function openPull(root, collection, repo, input, branches) {
+    if (!branches.includes(input.base) || !branches.includes(input.head)) {
+        throw new ops_1.OpError('Both the base and the compare branch must exist.');
+    }
+    return createPull(root, collection, repo, input);
+}
+/** The commit message a merge gets when the caller does not supply one. */
+function defaultMergeMessage(pull, method, body = '') {
+    return method === 'squash'
+        ? `${pull.title} (#${pull.number})\n\n${body.trim()}`.trimEnd()
+        : `Merge pull request #${pull.number} from ${pull.head}\n\n${pull.title}`;
+}
+/**
+ * Merge a pull request: check it is open, merge its head into its base, record
+ * the merge, and optionally delete the head branch.
+ *
+ * The caller fires the push event afterwards, since it holds the CI engine, and
+ * moving a branch is a push whichever transport did it.
+ */
+async function mergePull(root, repo, n, actor, request, opts) {
+    const pull = readPull(root, repo.collection, repo.name, n);
+    if (!pull)
+        throw new ops_1.OpError(`Pull request ${n} does not exist.`, 'notfound');
+    // 'conflict', because to a caller deciding whether to retry this is the same
+    // answer as "someone got there first" rather than "your request was malformed".
+    if (pull.state !== 'open')
+        throw new ops_1.OpError('This pull request is not open.', 'conflict');
+    const message = request.message?.trim() || defaultMergeMessage(pull, request.method, pull.body);
+    const outcome = await (0, ops_1.mergeBranch)(repo.dir, pull.base, pull.head, message, {
+        name: actor.username,
+        email: actor.email,
+    }, request.method);
+    if (outcome.status === 'conflict')
+        throw new MergeConflict(outcome.paths);
+    if (outcome.status === 'up-to-date') {
+        // 'conflict' rather than 'nochange': to a caller deciding whether to retry,
+        // "someone already merged this" is the same answer as "someone got there
+        // first", and a 200 saying nothing changed would read as success.
+        throw new ops_1.OpError(`${pull.base} already contains everything on ${pull.head}.`, 'conflict');
+    }
+    recordMerge(root, repo.collection, repo.name, n, { actor: actor.username, sha: outcome.sha });
+    let branchDeleted = false;
+    if (request.deleteBranch) {
+        // A failure to delete the branch must not read as a failure to merge, which
+        // has already happened and cannot be undone. It is reported as part of the
+        // result instead.
+        try {
+            await deletePullBranch(root, repo, n, opts);
+            branchDeleted = true;
+        }
+        catch (e) {
+            console.error(`merged #${n} but could not delete ${pull.head}: ${e instanceof Error ? e.message : e}`);
+        }
+    }
+    return { sha: outcome.sha, before: outcome.before, fastForward: outcome.fastForward, branchDeleted };
+}
+/**
+ * Delete the branch a pull request proposed: only that branch, only once the
+ * pull request is over, and never the branch it was merged into.
+ */
+async function deletePullBranch(root, repo, n, opts) {
+    const pull = readPull(root, repo.collection, repo.name, n);
+    if (!pull)
+        throw new ops_1.OpError(`Pull request ${n} does not exist.`, 'notfound');
+    if (pull.state !== 'merged') {
+        throw new ops_1.OpError('The branch can be deleted once this pull request is merged.', 'conflict');
+    }
+    if (pull.head === opts.defaultBranch)
+        throw new ops_1.OpError('The default branch cannot be deleted.');
+    await (0, ops_1.deleteBranch)(repo.dir, pull.head);
+    return pull.head;
+}