@catladder/cli 5.0.0 → 5.0.1

package/package.json

@@ -53,7 +53,7 @@
     }
   ],
   "license": "MIT",
-  "version": "5.0.0",
+  "version": "5.0.1",
   "scripts": {
     "lint": "eslint \"src/**/*.ts\"",
     "lint:fix": "eslint \"src/**/*.ts\" --fix",

package/src/release/__tests__/releaseEntry.test.ts

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createReleaseEntry } from "../releaseEntry";
+
+const gitlabEnv = {
+  GITHUB_ACTIONS: undefined,
+  GL_TOKEN: "glpat-token",
+  CI_API_V4_URL: "https://git.example.com/api/v4",
+  CI_PROJECT_ID: "42",
+};
+
+const githubEnv = {
+  GITHUB_ACTIONS: "true",
+  GITHUB_TOKEN: "gh-token",
+  GITHUB_REPOSITORY: "panter/catladder",
+};
+
+const stubEnv = (env: Record<string, string | undefined>) => {
+  Object.entries(env).forEach(([key, value]) => vi.stubEnv(key, value as any));
+};
+
+const stubFetch = (response: Partial<Response> = {}) => {
+  const fetchMock = vi.fn().mockResolvedValue({
+    ok: true,
+    status: 201,
+    text: async () => "",
+    ...response,
+  });
+  vi.stubGlobal("fetch", fetchMock);
+  return fetchMock;
+};
+
+afterEach(() => {
+  vi.unstubAllEnvs();
+  vi.unstubAllGlobals();
+});
+
+describe("createReleaseEntry", () => {
+  it("creates the gitlab release for the pushed tag", async () => {
+    stubEnv(gitlabEnv);
+    const fetchMock = stubFetch();
+
+    await createReleaseEntry("v1.2.0", "- Add the export endpoint");
+
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("https://git.example.com/api/v4/projects/42/releases");
+    expect(init.method).toBe("POST");
+    expect(init.headers["PRIVATE-TOKEN"]).toBe("glpat-token");
+    expect(JSON.parse(init.body)).toEqual({
+      tag_name: "v1.2.0",
+      description: "- Add the export endpoint",
+    });
+  });
+
+  it("creates the github release for the pushed tag", async () => {
+    stubEnv(githubEnv);
+    const fetchMock = stubFetch();
+
+    await createReleaseEntry("v1.2.0", "- Add the export endpoint");
+
+    const [url, init] = fetchMock.mock.calls[0];
+    expect(url).toBe("https://api.github.com/repos/panter/catladder/releases");
+    expect(init.headers.authorization).toBe("Bearer gh-token");
+    expect(JSON.parse(init.body)).toEqual({
+      tag_name: "v1.2.0",
+      name: "v1.2.0",
+      body: "- Add the export endpoint",
+    });
+  });
+
+  it("does not throw when the api call fails — the tag is already pushed", async () => {
+    stubEnv(gitlabEnv);
+    stubFetch({ ok: false, status: 403, text: async () => "forbidden" });
+
+    await expect(
+      createReleaseEntry("v1.2.0", "- notes"),
+    ).resolves.toBeUndefined();
+  });
+
+  it("skips without api context instead of failing the release", async () => {
+    stubEnv({ ...gitlabEnv, GL_TOKEN: undefined });
+    const fetchMock = stubFetch();
+
+    await createReleaseEntry("v1.2.0", "- notes");
+
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/release/changesetsReleaseJob.ts

@@ -23,6 +23,7 @@ import {
   git,
   gitWithEnv,
 } from "./releaseGit";
+import { createReleaseEntry } from "./releaseEntry";
 import { appendStepSummary } from "./stepSummary";
 
 const CHANGESET_DIR = ".changeset";
@@ -276,6 +277,8 @@ export const changesetsReleaseJob = async () => {
   await pushCommitAndTag(tag);
   console.log(`released ${tag}`);
   appendStepSummary(`🚀 **Released ${tag}**\n\n${entries}`);
+  // the tag alone creates no entry on the releases page of the git host
+  await createReleaseEntry(tag, entries);
 
   if (process.env.GITHUB_ACTIONS === "true") {
     await dispatchTaggedReleaseWorkflow(tag);

package/src/release/releaseEntry.ts

@@ -0,0 +1,86 @@
+/**
+ * the release entry on the git host — gitlab's `/-/releases`, github's
+ * `/releases`. Pushing a tag does NOT create one: on the
+ * semantic-release path `@semantic-release/gitlab` used to do it, the
+ * changesets path creates it here (on both backends).
+ *
+ * Never fatal: when this runs, the release commit and tag are already
+ * pushed and the taggedRelease pipeline is on its way — a failing api
+ * call must not turn a done release into a red job (and a rerun would
+ * fail on the existing tag).
+ */
+
+const post = async (
+  url: string,
+  headers: Record<string, string>,
+  body: unknown,
+) => {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body),
+  });
+  if (!response.ok) {
+    throw new Error(
+      `POST ${url} failed: ${response.status} ${await response.text()}`,
+    );
+  }
+};
+
+/**
+ * GL_TOKEN is the project access token the release push already used,
+ * so its api scope is available here too
+ */
+const createGitlabReleaseEntry = async (tag: string, notes: string) => {
+  const token = process.env.GL_TOKEN;
+  const apiUrl = process.env.CI_API_V4_URL;
+  const projectId = process.env.CI_PROJECT_ID;
+  if (!token || !apiUrl || !projectId) {
+    console.warn(
+      "no GL_TOKEN / gitlab api context — skipping the release entry (the tag is pushed)",
+    );
+    return;
+  }
+  await post(
+    `${apiUrl}/projects/${projectId}/releases`,
+    { "PRIVATE-TOKEN": token },
+    // name defaults to the tag on gitlab
+    { tag_name: tag, description: notes },
+  );
+  console.log(`created the gitlab release entry for ${tag}`);
+};
+
+/** the workflow token, granted `contents: write` by the release job */
+const createGithubReleaseEntry = async (tag: string, notes: string) => {
+  const token = process.env.GITHUB_TOKEN;
+  const apiUrl = process.env.GITHUB_API_URL ?? "https://api.github.com";
+  const repository = process.env.GITHUB_REPOSITORY;
+  if (!token || !repository) {
+    console.warn(
+      "no GITHUB_TOKEN / repository context — skipping the release entry (the tag is pushed)",
+    );
+    return;
+  }
+  await post(
+    `${apiUrl}/repos/${repository}/releases`,
+    { authorization: `Bearer ${token}`, accept: "application/vnd.github+json" },
+    { tag_name: tag, name: tag, body: notes },
+  );
+  console.log(`created the github release entry for ${tag}`);
+};
+
+export const createReleaseEntry = async (tag: string, notes: string) => {
+  try {
+    if (process.env.GITHUB_ACTIONS === "true") {
+      await createGithubReleaseEntry(tag, notes);
+    } else {
+      await createGitlabReleaseEntry(tag, notes);
+    }
+  } catch (error) {
+    console.warn(
+      `⚠️ could not create the release entry for ${tag}: ${error}\n` +
+        "the release itself is done (commit, tag and changelog are pushed) — " +
+        "create the entry by hand if you need it",
+    );
+  }
+};