chore(release): v1.2.0-BETA.1

.github/release/dashboard.mjs

@@ -10,7 +10,7 @@ import { createGitHub } from "./lib/github.mjs";
 const MARKER = "<!-- release-dashboard -->";
 const TITLE = "🚀 Releases en cours";
 const LABEL = "release";
-const PAIRS = new Set(["dev>beta", "beta>main"]);
+const PAIRS = new Set(["dev>main", "dev>beta", "beta>main"]);
 const TITLE_VERSION = /^chore\(release\): (v\S+)$/;
 
 // GitHub turns #N into a link to the pull request.

.github/release/lib/flow.mjs

@@ -0,0 +1,21 @@
+// The promotion chain. Until a v2 (maybe never), `beta` is skipped: dev is promoted straight to main
+// as a stable, and a release is brought back to dev straight from main.
+// To bring beta back: set BETA to true here, then put `beta` back in promote.yml's push branches (the
+// workflows' other conditions accept both chains).
+
+export const BETA = false;
+
+/** The promotions the bot opens, in release order. */
+export function promotions(beta = BETA) {
+  return beta
+    ? [
+        { source: "dev", target: "beta" },
+        { source: "beta", target: "main" },
+      ]
+    : [{ source: "dev", target: "main" }];
+}
+
+/** The branch `source` is promoted to, or null when it is not promoted. */
+export function promotionTarget(source, beta = BETA) {
+  return promotions(beta).find((p) => p.source === source)?.target ?? null;
+}

.github/release/lib/version.mjs

@@ -1,4 +1,5 @@
-// Version computation for the dev -> beta -> main release flow.
+// Version computation for the release flow: dev -> main while beta is skipped (lib/flow.mjs), else
+// dev -> beta -> main.
 // Tags are `vX.Y.Z` (stable) and `vX.Y.Z-BETA.N` (pre-release).
 
 const TAG = /^v(\d+)\.(\d+)\.(\d+)(?:-BETA\.(\d+))?$/;
@@ -74,6 +75,20 @@ export function nextBeta(lastStable, betaTags, subjects) {
   return format(target, n);
 }
 
+/**
+ * Next stable promoted straight from dev (beta skipped): lastStable bumped by the commits, or the highest
+ * target among the betas newer than lastStable when that is higher; null when no commit is releasable.
+ */
+export function nextDirectStable(lastStable, betaTags, subjects) {
+  const kind = bumpKind(subjects, lastStable);
+  if (kind === null) return null;
+  let target = bump(parseVersion(lastStable), kind);
+  for (const beta of betaTags.map(parseVersion)) {
+    if (beta.beta !== null && compare(beta, target) > 0) target = beta;
+  }
+  return format(target);
+}
+
 export function nextStable(betaTag) {
   const version = parseVersion(betaTag);
   if (version.beta === null) throw new Error(`Not a beta tag: ${betaTag}`);

.github/release/promote.mjs

@@ -1,10 +1,12 @@
 // Opens (in draft) or refreshes the single promotion PR from `source` to `target`.
-// CLI: node .github/release/promote.mjs --source dev --target beta
-// (env: GH_TOKEN, GITHUB_REPOSITORY=owner/repo, APP_SLUG = the release App's slug)
+// CLI: node .github/release/promote.mjs --source dev [--target main]
+// (--target defaults to the source's next branch in lib/flow.mjs; env: GH_TOKEN,
+// GITHUB_REPOSITORY=owner/repo, APP_SLUG = the release App's slug)
 
 import { parseArgs } from "node:util";
 import { pathToFileURL } from "node:url";
-import { parseVersion, bumpKind, nextBeta, nextStable } from "./lib/version.mjs";
+import { parseVersion, bumpKind, nextBeta, nextDirectStable, nextStable } from "./lib/version.mjs";
+import { promotionTarget } from "./lib/flow.mjs";
 import { buildBody, parseBody, scheduledText, seenId, setPromotedHead, setScheduledText, updateBody } from "./lib/pr-body.mjs";
 import { activeSchedule, NO_SCHEDULE } from "./lib/schedule.mjs";
 import { createGitHub } from "./lib/github.mjs";
@@ -37,16 +39,20 @@ export function compareVersions(a, b) {
 }
 
 /**
- * Stable for a promotion to `main`, beta otherwise; null when there is nothing to release. `commits`
- * are the promoted ones (release commits left out). ready.mjs checks the PR title against it.
+ * Stable for a promotion to `main` (dev -> main bumps the last stable, beta -> main finishes the last
+ * beta), beta otherwise; null when there is nothing to release. `commits` are the promoted ones
+ * (release commits left out). ready.mjs checks the PR title against it.
  */
-export function releaseVersion(target, tags, commits) {
+export function releaseVersion(source, target, tags, commits) {
   const versions = versionTags(tags).sort(compareVersions);
   const stables = versions.filter((v) => v.beta === null);
   const lastStable = stables.length ? stables[stables.length - 1] : { tag: "v0.0.0", ...parseVersion("v0.0.0") };
   const betas = versions.filter((v) => v.beta !== null && compareVersions(v, lastStable) > 0);
-  if (target === "main") return betas.length ? nextStable(betas[betas.length - 1].tag) : null;
   const messages = commits.map((c) => c.message);
+  if (target === "main" && source === "dev") {
+    return nextDirectStable(lastStable.tag, betas.map((v) => v.tag), messages);
+  }
+  if (target === "main") return betas.length ? nextStable(betas[betas.length - 1].tag) : null;
   if (bumpKind(messages, lastStable.tag) === null && betas.length === 0) return null;
   return nextBeta(lastStable.tag, betas.map((v) => v.tag), messages);
 }
@@ -97,7 +103,7 @@ export async function promote({ gh, source, target, owner, repo, appSlug }) {
     return { action: "closed", number: pull.number };
   }
 
-  const version = releaseVersion(target, await gh.listTags(), commits);
+  const version = releaseVersion(source, target, await gh.listTags(), commits);
   if (version === null) return withNumber("none");
   const title = `chore(release): ${version}`;
 
@@ -137,7 +143,8 @@ export async function promote({ gh, source, target, owner, repo, appSlug }) {
 
 if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
   const { values } = parseArgs({ options: { source: { type: "string" }, target: { type: "string" } } });
-  if (!values.source || !values.target) throw new Error("Usage: promote.mjs --source <branch> --target <branch>");
+  values.target ??= values.source ? (promotionTarget(values.source) ?? undefined) : undefined;
+  if (!values.source || !values.target) throw new Error("Usage: promote.mjs --source <branch> [--target <branch>]");
   const [owner, repo] = (process.env.GITHUB_REPOSITORY ?? "").split("/");
   const gh = createGitHub({ token: process.env.GH_TOKEN, owner, repo });
   const result = await promote({ ...values, gh, owner, repo, appSlug: process.env.APP_SLUG });

.github/release/publish.mjs

@@ -1,5 +1,6 @@
 // A promotion (or hotfix) PR was merged: tag its merge commit, and after a stable or a hotfix open
-// the backport PRs that bring it back to dev (main -> beta, then beta -> dev once that one is merged). The tag is pushed with the App token, so its push event runs
+// the backport PRs that bring it back to dev, with auto-merge (main -> dev while beta is skipped, else
+// main -> beta, then beta -> dev once that one is merged). The tag is pushed with the App token, so its push event runs
 // release.yml, the single publication path (it reads the PR's notes itself). After a beta, the beta -> main
 // promotion is retitled by publish.yml's own job, in the promote-beta concurrency group, not here.
 // CLI: node .github/release/publish.mjs --number 12
@@ -10,6 +11,7 @@ import { pathToFileURL } from "node:url";
 import { createGitHub } from "./lib/github.mjs";
 import { refreshDashboardSafely } from "./dashboard.mjs";
 import { kindOf, titleVersion } from "./ready.mjs";
+import { BETA } from "./lib/flow.mjs";
 
 const short = (sha) => sha.slice(0, 7);
 const pattern = (kind) => (kind === "beta" ? "vX.Y.Z-BETA.N" : "vX.Y.Z");
@@ -32,40 +34,63 @@ function isBackportToBeta(pr, repository) {
   return pr.headRepo === repository && pr.head === "main" && pr.base === "beta" && pr.labels?.includes("backport");
 }
 
-function backportBody(tag, pr, from, to) {
+function backportBody(tag, pr, from, to, autoMerge) {
   return (
     `Report de \`${tag}\` (#${pr.number}) de \`${from}\` vers \`${to}\`.\n\n` +
-    `Fusionne cette PR par commit de merge pour ramener la release sur \`${to}\` ; tant qu'elle est ` +
-    `ouverte, la promotion depuis et vers \`${to}\` est refusée.\n`
+    (autoMerge
+      ? `L'auto-merge est activé : la PR se fusionne d'elle-même (commit de merge) dès que les checks passent`
+      : `Fusionne cette PR par commit de merge pour ramener la release sur \`${to}\``) +
+    ` ; tant qu'elle est ouverte, la promotion depuis et vers \`${to}\` est refusée.\n`
   );
 }
 
+/** Auto-merge (merge commit) pinned to the backport's head; a failure leaves the merge to the owner. */
+async function autoMergeBackport(gh, created, title) {
+  try {
+    await gh.enableAutoMerge(created, { expectedHeadOid: created.headSha, commitHeadline: title });
+    return true;
+  } catch (error) {
+    console.warn(`::warning::#${created.number}: could not enable auto-merge: ${error.message}`);
+    return false;
+  }
+}
+
 /**
- * Opens the backport PR `from` -> `to` unless one is open (it is reused) or there is nothing to bring.
+ * Opens the backport PR `from` -> `to`, with auto-merge, unless one is open (it is reused) or there is
+ * nothing to bring.
  * -> {number} when opened, {pending: true} when one is already open, null when there is nothing to bring.
  */
 async function openBackport(gh, tag, pr, from, to) {
   const [open, commits] = await Promise.all([gh.listPulls({ base: to, head: from }), gh.compareCommits(to, from)]);
   if (open.length) return { pending: true };
   if (commits.length === 0) return null;
+  const title = `chore(release): backport ${tag} to ${to}`;
   const created = await gh.createPull({
-    title: `chore(release): backport ${tag} to ${to}`,
+    title,
     base: to,
     head: from,
     draft: false,
     labels: ["backport"],
-    body: backportBody(tag, pr, from, to),
+    body: backportBody(tag, pr, from, to, true),
   });
   console.log(`opened the backport #${created.number} ${from} -> ${to}`);
+  if (!(await autoMergeBackport(gh, created, title))) {
+    await gh.updatePull(created.number, { body: backportBody(tag, pr, from, to, false) });
+  }
   return { number: created.number };
 }
 
 /**
  * Brings the release back to dev, whose version line would otherwise conflict with the next
- * promotion: a stable through beta -> dev; a hotfix through main -> beta first, beta -> dev being
- * opened once that one is merged (or right away when beta needs nothing). Returns the PRs opened.
+ * promotion. Beta skipped (lib/flow.mjs): main -> dev. Otherwise a stable through beta -> dev; a hotfix
+ * through main -> beta first, beta -> dev being opened once that one is merged (or right away when beta
+ * needs nothing). Returns the PRs opened.
  */
-async function openBackports(gh, tag, pr, kind) {
+async function openBackports(gh, tag, pr, kind, beta) {
+  if (!beta && kind !== "backport") {
+    const toDev = await openBackport(gh, tag, pr, "main", "dev");
+    return toDev?.number ? [toDev.number] : [];
+  }
   if (kind === "hotfix") {
     const toBeta = await openBackport(gh, tag, pr, "main", "beta");
     if (toBeta !== null) return toBeta.number ? [toBeta.number] : [];
@@ -74,31 +99,33 @@ async function openBackports(gh, tag, pr, kind) {
   return toDev?.number ? [toDev.number] : [];
 }
 
-async function release(gh, pr, kind) {
+async function release(gh, pr, kind, beta) {
   if (!pr.merged || !pr.mergeCommitSha) throw new Error(`#${pr.number} is not merged`);
   const tag = titleVersion(pr.title, kind);
   if (tag === null) throw new Error(`#${pr.number}: the title does not carry the version to publish: ${pr.title}`);
 
   await ensureTag(gh, tag, pr.mergeCommitSha, pr.title);
-  const backports = kind === "beta" ? [] : await openBackports(gh, tag, pr, kind);
+  // A stable promoted from beta goes back through beta -> dev, whatever the current chain.
+  const through = kind === "stable" && pr.head === "beta" ? true : beta;
+  const backports = kind === "beta" ? [] : await openBackports(gh, tag, pr, kind, through);
   return { tag, backports };
 }
 
 /**
  * -> {tag, backports} (numbers of the backport PRs opened). Throws on an unmerged or unrelated PR; a
- * failure on a release PR is also reported on it.
+ * failure on a release PR is also reported on it. `beta`: whether the chain goes through beta.
  */
-export async function publish({ gh, pr, owner, repo }) {
+export async function publish({ gh, pr, owner, repo, beta = BETA }) {
   if (isBackportToBeta(pr, `${owner}/${repo}`)) {
     if (!pr.merged) throw new Error(`#${pr.number} is not merged`);
     const tag = BACKPORT_TITLE.exec(pr.title)?.[1];
     if (!tag) throw new Error(`#${pr.number}: the title does not carry the backported version: ${pr.title}`);
-    return { tag, backports: await openBackports(gh, tag, pr, "stable") };
+    return { tag, backports: await openBackports(gh, tag, pr, "backport", true) };
   }
   const kind = kindOf(pr, `${owner}/${repo}`);
   if (kind === null) throw new Error(`#${pr.number} is not a promotion or hotfix pull request`);
   try {
-    return await release(gh, pr, kind);
+    return await release(gh, pr, kind, beta);
   } catch (error) {
     const version = titleVersion(pr.title, kind);
     if (pr.merged) {

.github/release/ready.mjs

@@ -30,11 +30,14 @@ export function bumpGradleVersion(text, version) {
   return text.replace(VERSION_LINE, (_, prefix) => `${prefix}"${version}"`);
 }
 
-/** Promotions dev -> beta and beta -> main, and hotfixes into main, all from this repository. */
+/**
+ * Promotions dev -> main (beta skipped, lib/flow.mjs), dev -> beta and beta -> main, and hotfixes into
+ * main, all from this repository.
+ */
 export function kindOf(pull, repository) {
   if (pull.headRepo !== repository) return null;
   if (pull.head === "dev" && pull.base === "beta") return "beta";
-  if (pull.head === "beta" && pull.base === "main") return "stable";
+  if ((pull.head === "dev" || pull.head === "beta") && pull.base === "main") return "stable";
   if (pull.head.startsWith("hotfix/") && pull.base === "main") return "hotfix";
   return null;
 }
@@ -164,7 +167,7 @@ async function prepare({ gh, pr, pull, kind, owner, repo, appSlug, promote, wait
   if (promotion) {
     const [tags, compared] = await Promise.all([gh.listTags(), gh.compareCommits(pull.base, pull.head)]);
     const promoted = compared.filter((c) => !isReleaseCommit(c, appSlug));
-    const expected = releaseVersion(pull.base, tags, promoted);
+    const expected = releaseVersion(pull.head, pull.base, tags, promoted);
     if (expected !== version) return refuseAndRefresh(gh, pull, MESSAGES.staleVersion(version, expected), refresh);
   }
 

.github/release/schedule.mjs

@@ -1,9 +1,10 @@
 // Scheduled releases. --confirm answers the owner's edits of a promotion PR: only the App's comment
 // makes a date active. --due lists the source branches whose date has come, and --run takes their PR
 // out of draft, then follows the same path as the owner doing it.
-// CLI: node .github/release/schedule.mjs --confirm | --due | --run --source dev --target beta
+// CLI: node .github/release/schedule.mjs --confirm | --due | --run --source dev [--target main]
 // (env: GH_TOKEN, GITHUB_REPOSITORY=owner/repo, APP_SLUG = the release App's slug; GITHUB_EVENT_PATH
-// for --confirm, GITHUB_OUTPUT for --due)
+// for --confirm, GITHUB_OUTPUT for --due). --run takes the target from lib/flow.mjs: --target is only
+// a fallback, so an older release-schedule.yml (still on main until the next release) stays right.
 
 import { appendFileSync, readFileSync } from "node:fs";
 import { parseArgs } from "node:util";
@@ -13,11 +14,7 @@ import { activeSchedule, formatParis, NO_SCHEDULE, parseScheduleDate, scheduleMa
 import { createGitHub } from "./lib/github.mjs";
 import { isReleaseCommit } from "./promote.mjs";
 import { kindOf, onReady } from "./ready.mjs";
-
-export const PROMOTIONS = [
-  { source: "dev", target: "beta" },
-  { source: "beta", target: "main" },
-];
+import { BETA, promotions, promotionTarget } from "./lib/flow.mjs";
 // Past this delay, the start of the release says it is late (GitHub's schedules may be delayed).
 export const LATE_NOTICE_MS = 60 * 60 * 1000;
 
@@ -72,9 +69,9 @@ export async function confirm({ gh, event, owner, repo, appSlug, now = new Date(
 }
 
 /** The source branches of the open promotions whose scheduled date has come. */
-export async function dueSources({ gh, appSlug, now = new Date() }) {
+export async function dueSources({ gh, appSlug, now = new Date(), beta = BETA }) {
   const due = [];
-  for (const { source, target } of PROMOTIONS) {
+  for (const { source, target } of promotions(beta)) {
     const [pull] = await gh.listPulls({ base: target, head: source });
     if (!pull) continue;
     const active = activeSchedule(await gh.listComments(pull.number), appSlug);
@@ -156,9 +153,10 @@ if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {
     const due = await dueSources({ gh, appSlug });
     console.log(due);
     appendFileSync(process.env.GITHUB_OUTPUT, `sources=${JSON.stringify(due)}\n`);
-  } else if (values.run && values.source && values.target) {
-    console.log(await run({ gh, source: values.source, target: values.target, owner, repo, appSlug }));
+  } else if (values.run && values.source && (promotionTarget(values.source) ?? values.target)) {
+    const target = promotionTarget(values.source) ?? values.target;
+    console.log(await run({ gh, source: values.source, target, owner, repo, appSlug }));
   } else {
-    throw new Error("Usage: schedule.mjs --confirm | --due | --run --source <branch> --target <branch>");
+    throw new Error("Usage: schedule.mjs --confirm | --due | --run --source <branch> [--target <branch>]");
   }
 }

.github/release/test/dashboard.test.mjs

@@ -71,15 +71,17 @@ test("refresh_derivesStateFromThePullRequests", async () => {
       pull(1),
       pull(2, { draft: false }),
       pull(3, { draft: false, autoMerge: true, head: "beta", base: "main", title: "chore(release): v1.0.0" }),
-      pull(4, { draft: false, base: "main", head: "dev" }), // not a promotion pair
+      pull(4, { draft: false, base: "main", head: "feat/x" }), // not a promotion pair
       pull(5, { labels: ["backport"], head: "main", base: "beta" }),
       pull(6, { labels: [] }),
+      pull(7, { base: "main", head: "dev", title: "chore(release): v1.2.0" }), // beta skipped
     ],
     mergeStates: { 2: "DIRTY" },
   });
   await refreshDashboard({ gh });
   const body = gh.calls.find(([name]) => name === "create")[1].body;
   assert.match(body, /v1\.0\.0-BETA\.1 \| draft \| #1/);
+  assert.match(body, /`dev` → `main` \| v1\.2\.0 \| draft \| #7/);
   assert.match(body, /v1\.0\.0-BETA\.2 \| en conflit \| #2/);
   assert.match(body, /\| v1\.0\.0 \| prête \(auto-merge\) \| #3/);
   assert.doesNotMatch(body, /#4|#6/);

.github/release/test/promote.test.mjs

@@ -171,6 +171,24 @@ test("betaToMain_usesTheStableOfTheLatestBeta", async () => {
   assert.equal(gh.calls[0][1].title, "chore(release): v1.0.0");
 });
 
+test("devToMain_bumpsTheLastStableStraightAway", async () => {
+  const gh = fakeGitHub({
+    tags: ["v1.0.0-BETA.102", "v1.1.0-BETA.1", "v1.1.0"],
+    ahead: { "main...dev": [commit("a", "feat: x"), commit("b", "fix: y")] },
+  });
+  assert.deepEqual(await run(gh, "dev", "main"), { action: "created", number: 100 });
+  const [[, created]] = gh.calls;
+  assert.equal(created.title, "chore(release): v1.2.0");
+  assert.equal(created.base, "main");
+  assert.equal(created.head, "dev");
+});
+
+test("devToMain_withoutReleasableCommit_doesNothing", async () => {
+  const gh = fakeGitHub({ tags: ["v1.1.0"], ahead: { "main...dev": [commit("a", "not conventional")] } });
+  assert.deepEqual(await run(gh, "dev", "main"), { action: "none" });
+  assert.deepEqual(gh.calls, []);
+});
+
 test("betaToMain_withoutBeta_doesNothing", async () => {
   const gh = fakeGitHub({ tags: ["v1.0.0"], ahead: { "main...beta": [commit("a", "fix: x")] } });
   assert.deepEqual(await run(gh, "beta", "main"), { action: "none" });