pr-merge-queue 0.0.0-stage → 0.0.0

package/src/unblock-prs/github.test.mts

@@ -0,0 +1,84 @@
+import { latestMergedHead, pullRequestOfNode } from './github.mjs';
+
+describe(pullRequestOfNode, () => {
+  const node = {
+    number: 12,
+    id: 'PR_kwDO',
+    title: 'feat: x',
+    body: 'Merge-After: #11',
+    state: 'OPEN',
+    headRefName: 'feat/x',
+    headRefOid: 'a'.repeat(40),
+    baseRefName: 'main',
+    isCrossRepository: false,
+    isDraft: false,
+    mergeStateStatus: 'BEHIND',
+    autoMergeRequest: null,
+    labels: { nodes: [{ name: 'merge-queued' }, { name: 'skip-ci' }] },
+  } as const;
+
+  test('flattens the labels to the shape every module here reads', () => {
+    assert.deepStrictEqual(pullRequestOfNode(node).labels, [
+      { name: 'merge-queued' },
+      { name: 'skip-ci' },
+    ]);
+  });
+
+  test('keeps every other field as GitHub answered it', () => {
+    const { labels: _labels, ...rest } = pullRequestOfNode(node);
+
+    const { labels: _nodeLabels, ...expected } = node;
+
+    assert.deepStrictEqual(rest, expected);
+  });
+
+  test('keeps an armed auto-merge a record, which is what is read of it', () => {
+    const armed = pullRequestOfNode({
+      ...node,
+      autoMergeRequest: { enabledAt: '2026-10-25T00:00:00Z' },
+    });
+
+    assert.deepStrictEqual(armed.autoMergeRequest, {
+      enabledAt: '2026-10-25T00:00:00Z',
+    });
+  });
+});
+
+describe(latestMergedHead, () => {
+  test('is the pull request merged last, and ignores one closed unmerged', () => {
+    assert.deepStrictEqual(
+      latestMergedHead([
+        pull(1, '2026-10-01T00:00:00Z'),
+        pull(3, null),
+        pull(2, '2026-10-02T00:00:00Z'),
+      ]),
+      {
+        number: 2,
+        headSha: '2'.padStart(40, 'h'),
+        mergeCommit: '2'.padStart(40, 'c'),
+      },
+    );
+  });
+
+  test('is undefined when none was merged', () => {
+    assert.isUndefined(latestMergedHead([pull(3, null)]));
+  });
+
+  test('leaves the merge commit out while GitHub has none', () => {
+    assert.isUndefined(
+      latestMergedHead([pull(1, '2026-10-01T00:00:00Z', null)])?.mergeCommit,
+    );
+  });
+});
+
+const pull = (
+  number: number,
+  mergedAt: string | null,
+  mergeCommit: string | null = number.toString().padStart(40, 'c'),
+): Parameters<typeof latestMergedHead>[0][number] =>
+  ({
+    number,
+    head: { sha: number.toString().padStart(40, 'h') },
+    merge_commit_sha: mergeCommit,
+    merged_at: mergedAt,
+  }) as const;

package/src/unblock-prs/index.mts

@@ -0,0 +1,24 @@
+export * from './auto-fix.mjs';
+export * from './checks.mjs';
+export * from './claims.mjs';
+export * from './config.mjs';
+export * from './constants.mjs';
+export * from './demotions.mjs';
+export * from './github.mjs';
+export * from './labels.mjs';
+export * from './main.mjs';
+export * from './merge-after.mjs';
+export * from './options.mjs';
+export * from './owner.mjs';
+export * from './quiet.mjs';
+export * from './rebase.mjs';
+export * from './release.mjs';
+export * from './set-aside-comment.mjs';
+export * from './set-aside-detail.mjs';
+export * from './skips.mjs';
+export * from './stack.mjs';
+export * from './triage.mjs';
+export * from './types.mjs';
+export * from './util.mjs';
+export * from './version-pr.mjs';
+export * from './watch.mjs';

package/src/unblock-prs/labels.mts

@@ -0,0 +1,70 @@
+/**
+ * What the labels this script reads say about one pull request.
+ * `merge-queued` decides whether a pull request is looked at, `skip-ci`
+ * decides whether it has been released yet, and `blocks-release` decides
+ * whether the version pull request may go at all, `auto-rebase` asks for a
+ * paused pull request to be kept on the tip, and `priority:high` /
+ * `priority:low` move one within the pick order. The strings themselves are
+ * `pr-report-core`'s, because the Pull Requests Manager page reads them too.
+ */
+
+import {
+  AUTO_REBASE_LABEL,
+  BLOCKS_RELEASE_LABEL,
+  MERGE_QUEUED_LABEL,
+  priorityOfLabels,
+  priorityRankOfLabels,
+  SKIP_CI_LABEL,
+  type QueuePriority,
+} from 'pr-report-core';
+import type { PullRequest } from './types.mjs';
+
+/**
+ * Whether the pull request carries the `skip-ci` label, which is what this
+ * repository uses to say "not yet": the check workflows skip while it is on
+ * and `skip-ci-label.yml` holds the merge with a `pending` `no-skip-ci-label` status,
+ * so there is nothing here to unblock.
+ */
+export const isSkipCiLabelled = (pr: PullRequest): boolean =>
+  pr.labels.some((label) => label.name === SKIP_CI_LABEL);
+
+/**
+ * Whether the pull request has been put in the queue — reviewed, and waiting
+ * for its turn rather than for someone to look at it. This is the scope rule:
+ * a pull request without the label is not this script's business, whatever
+ * else it carries.
+ */
+export const isMergeQueued = (pr: PullRequest): boolean =>
+  pr.labels.some((label) => label.name === MERGE_QUEUED_LABEL);
+
+/**
+ * Whether the pull request declares that the release must wait for it. A
+ * draft counts: holding a release for something that is not ready yet is the
+ * case the label is for.
+ */
+export const blocksRelease = (pr: PullRequest): boolean =>
+  pr.labels.some((label) => label.name === BLOCKS_RELEASE_LABEL);
+
+/**
+ * Whether the pull request asked to be kept on the tip of the default branch
+ * while it waits, by `auto-rebase`, or by being queued: either way the author
+ * wants it rebased, and while `skip-ci` is on a rebase before its turn costs
+ * nothing and makes its diff easier to read.
+ */
+export const wantsAutoRebase = (pr: PullRequest): boolean =>
+  isMergeQueued(pr) ||
+  pr.labels.some((label) => label.name === AUTO_REBASE_LABEL);
+
+/**
+ * Which priority label the pull request carries (`priorityOfLabels`): `both`
+ * is the two at once, which contradict each other and so count as neither.
+ */
+export const priorityOf = (pr: PullRequest): QueuePriority =>
+  priorityOfLabels(pr.labels.map(({ name }) => name));
+
+/**
+ * Where {@link priorityOf} puts the pull request in the pick order, as a sort
+ * key: `high` before the rest, `low` after them.
+ */
+export const priorityRank = (pr: PullRequest): 0 | 1 | 2 =>
+  priorityRankOfLabels(pr.labels.map(({ name }) => name));