@swisspost/design-system-changelog-github 10.0.0-next.72 → 10.0.0-next.76

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @swisspost/design-system-changelog-github
 
+## 10.0.0-next.76
+
+## 10.0.0-next.75
+
+### Minor Changes
+
+- Updated dependencies, co-contributors are now mentioned in changelogs and added a delay when making GitHub API calls to enable exiting pre-mode with 900+ changesets. (by [@gfellerph](https://github.com/gfellerph) with [#7923](https://github.com/swisspost/design-system/pull/7923))
+
+## 10.0.0-next.74
+
+## 10.0.0-next.73
+
 ## 10.0.0-next.72
 
 ## 10.0.0-next.71

package/dist/index.js

@@ -5,8 +5,245 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const dotenv_1 = require("dotenv");
-const get_github_info_1 = require("@changesets/get-github-info");
 (0, dotenv_1.config)();
+// ---------------------------------------------------------------------------
+// Configuration (override via environment variables)
+// ---------------------------------------------------------------------------
+const GITHUB_TOKEN = process.env.GITHUB_TOKEN;
+const GITHUB_GRAPHQL_URL = process.env.GITHUB_GRAPHQL_URL || 'https://api.github.com/graphql';
+const GITHUB_SERVER_URL = process.env.GITHUB_SERVER_URL || 'https://github.com';
+// Abort a single GitHub request if it stalls, then retry on timeouts or
+// secondary rate limits.
+const REQUEST_TIMEOUT_MS = Number(process.env.CHANGELOG_REQUEST_TIMEOUT_MS) || 30_000;
+const MAX_RETRIES = Number(process.env.CHANGELOG_MAX_RETRIES) || 1;
+// Max commits to request per batched GraphQL call. Smaller batches keep each
+// query cheap and fast so it is far less likely to time out.
+const COMMIT_BATCH_SIZE = Number(process.env.CHANGELOG_COMMIT_BATCH_SIZE) || 25;
+// Minimum delay between the start of any two GitHub requests, to avoid bursts
+// that trigger GitHub's secondary rate limiting.
+const MIN_REQUEST_INTERVAL_MS = Number(process.env.CHANGELOG_MIN_REQUEST_INTERVAL_MS) || 100;
+const EMPTY_COMMIT_INFO = {
+    links: { commit: null, pull: null, user: null },
+    user: null,
+    coAuthors: [],
+};
+// Cache commit info by commit hash to avoid duplicate API calls
+const commitInfoCache = new Map();
+let throttleChain = Promise.resolve();
+let lastRequestStartedAt = 0;
+/**
+ * Resolves once it is this caller's turn to start a request, guaranteeing at
+ * least MIN_REQUEST_INTERVAL_MS between the start of any two requests. Calls are
+ * serialized through a single promise chain so concurrent callers queue in
+ * order.
+ */
+function throttleRequest() {
+    throttleChain = throttleChain.then(async () => {
+        const wait = lastRequestStartedAt + MIN_REQUEST_INTERVAL_MS - Date.now();
+        if (wait > 0) {
+            await new Promise(resolve => setTimeout(resolve, wait));
+        }
+        lastRequestStartedAt = Date.now();
+    });
+    return throttleChain;
+}
+async function githubFetch(url, token, init = {}) {
+    for (let attempt = 0;; attempt++) {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+        try {
+            // Space out requests so we never send more than one per
+            // MIN_REQUEST_INTERVAL_MS to GitHub.
+            await throttleRequest();
+            const response = await fetch(url, {
+                method: init.method,
+                body: init.body,
+                headers: {
+                    'Authorization': `Token ${token}`,
+                    'Accept': 'application/vnd.github.v3+json',
+                    'User-Agent': 'swisspost-design-system-changelog',
+                    ...init.headers,
+                },
+                signal: controller.signal,
+            });
+            // Honor GitHub secondary rate limit / abuse detection responses.
+            if ((response.status === 403 || response.status === 429) && attempt < MAX_RETRIES) {
+                const retryAfter = Number(response.headers.get('retry-after'));
+                const waitMs = Number.isFinite(retryAfter) && retryAfter > 0 ? retryAfter * 1000 : 2 ** attempt * 1000;
+                process.stderr.write(`\n⏳ Changelog: rate limited (${response.status}) for ${url}, retrying in ${Math.round(waitMs / 1000)}s\n`);
+                await new Promise(resolve => setTimeout(resolve, waitMs));
+                continue;
+            }
+            return response;
+        }
+        catch (error) {
+            const isTimeout = error instanceof Error && error.name === 'AbortError';
+            if (attempt < MAX_RETRIES) {
+                const waitMs = 2 ** attempt * 1000;
+                process.stderr.write(`\n⏳ Changelog: ${isTimeout ? `request timed out after ${REQUEST_TIMEOUT_MS / 1000}s` : 'request failed'} for ${url}, retrying in ${Math.round(waitMs / 1000)}s\n`);
+                await new Promise(resolve => setTimeout(resolve, waitMs));
+                continue;
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+let pendingCommits = [];
+let flushScheduled = false;
+function scheduleCommitFlush() {
+    if (flushScheduled)
+        return;
+    flushScheduled = true;
+    // Flush on the next microtask so every getReleaseLine call made in this tick
+    // is collected into a single batch.
+    queueMicrotask(() => {
+        flushScheduled = false;
+        const batch = pendingCommits;
+        pendingCommits = [];
+        void flushCommitBatch(batch);
+    });
+}
+function buildCommitInfoQuery(repoOrder, reposToCommits) {
+    const selection = `... on Commit {
+    commitUrl
+    message
+    author { user { login url } }
+    associatedPullRequests(first: 50) {
+      nodes { number url mergedAt author { login url } }
+    }
+  }`;
+    const body = repoOrder
+        .map((repo, i) => {
+        const [owner, name] = repo.split('/');
+        const objects = [...reposToCommits.get(repo)]
+            .map(oid => `c_${oid}: object(expression: ${JSON.stringify(oid)}) { ${selection} }`)
+            .join('\n');
+        return `r${i}: repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {\n${objects}\n}`;
+    })
+        .join('\n');
+    return `query {\n${body}\n}`;
+}
+/** Parse Co-authored-by trailers from a squash merge commit message. */
+function parseCoAuthors(message, mainUserLogin) {
+    const users = new Set();
+    const coAuthorMatches = message.matchAll(/^Co-authored-by:\s+.+<([^>]+)>/gm);
+    for (const match of coAuthorMatches) {
+        // GitHub noreply emails contain the username
+        const noreplyMatch = match[1].match(/^(\d+\+)?([^@]+)@users\.noreply\.github\.com$/);
+        if (noreplyMatch) {
+            users.add(noreplyMatch[2]);
+        }
+    }
+    // Remove the main PR author and bots
+    if (mainUserLogin)
+        users.delete(mainUserLogin);
+    for (const user of users) {
+        if (user.endsWith('[bot]') || user === 'web-flow') {
+            users.delete(user);
+        }
+    }
+    return [...users].map(login => `[@${login}](${GITHUB_SERVER_URL}/${login})`);
+}
+/** Derive links + co-authors from a commit node, mirroring getInfo's logic. */
+function deriveCommitInfo(commit, node) {
+    if (!node)
+        return EMPTY_COMMIT_INFO;
+    let user = node.author?.user ?? null;
+    // Pick the earliest-merged associated PR (unmerged PRs rank last), matching
+    // getInfo's behavior.
+    const prNodes = node.associatedPullRequests?.nodes ?? [];
+    const mergedRank = (pr) => pr.mergedAt ? new Date(pr.mergedAt).getTime() : Infinity;
+    const associatedPullRequest = prNodes.length
+        ? prNodes.reduce((best, pr) => (mergedRank(pr) < mergedRank(best) ? pr : best))
+        : null;
+    // Prefer the PR author over the commit author, matching getInfo's behavior.
+    if (associatedPullRequest) {
+        user = associatedPullRequest.author;
+    }
+    return {
+        links: {
+            commit: `[\`${commit.slice(0, 7)}\`](${node.commitUrl})`,
+            pull: associatedPullRequest
+                ? `[#${associatedPullRequest.number}](${associatedPullRequest.url})`
+                : null,
+            user: user ? `[@${user.login}](${user.url})` : null,
+        },
+        user: user ? user.login : null,
+        coAuthors: parseCoAuthors(node.message, user ? user.login : null),
+    };
+}
+async function flushCommitBatch(batch) {
+    if (batch.length === 0)
+        return;
+    if (!GITHUB_TOKEN) {
+        process.stderr.write(`\n⚠️ Changelog: GITHUB_TOKEN is not set, skipping GitHub info lookup\n`);
+        for (const item of batch)
+            item.resolve(EMPTY_COMMIT_INFO);
+        return;
+    }
+    // Process in chunks so a single GraphQL request never gets too large. Chunks
+    // run sequentially to stay gentle on the API.
+    for (let start = 0; start < batch.length; start += COMMIT_BATCH_SIZE) {
+        const chunk = batch.slice(start, start + COMMIT_BATCH_SIZE);
+        const reposToCommits = new Map();
+        for (const { repo, commit } of chunk) {
+            if (!reposToCommits.has(repo))
+                reposToCommits.set(repo, new Set());
+            reposToCommits.get(repo).add(commit);
+        }
+        const repoOrder = [...reposToCommits.keys()];
+        const query = buildCommitInfoQuery(repoOrder, reposToCommits);
+        try {
+            const response = await githubFetch(GITHUB_GRAPHQL_URL, GITHUB_TOKEN, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ query }),
+            });
+            if (!response.ok) {
+                process.stderr.write(`\n⚠️ Changelog: GitHub GraphQL returned ${response.status} ${response.statusText} for a commit-info batch\n`);
+                for (const item of chunk)
+                    item.resolve(EMPTY_COMMIT_INFO);
+                continue;
+            }
+            const json = (await response.json());
+            if (json.errors) {
+                process.stderr.write(`\n⚠️ Changelog: GitHub GraphQL returned errors for a commit-info batch: ${JSON.stringify(json.errors)}\n`);
+            }
+            const data = json.data ?? {};
+            for (const item of chunk) {
+                const repoIndex = repoOrder.indexOf(item.repo);
+                const node = data[`r${repoIndex}`]?.[`c_${item.commit}`] ?? null;
+                item.resolve(deriveCommitInfo(item.commit, node));
+            }
+        }
+        catch (error) {
+            process.stderr.write(`\n⚠️ Changelog: commit-info batch request failed: ${error instanceof Error ? error.message : String(error)}\n`);
+            for (const item of chunk)
+                item.reject(error);
+        }
+    }
+}
+/**
+ * Look up PR/user links and co-authors for a commit. Lookups are batched into a
+ * single GraphQL request per tick and cached by commit hash.
+ */
+function loadCommitInfo(repo, commit) {
+    const cached = commitInfoCache.get(commit);
+    if (cached)
+        return cached;
+    const promise = new Promise((resolve, reject) => {
+        pendingCommits.push({ repo, commit, resolve, reject });
+        scheduleCommitFlush();
+    });
+    // Evict on failure so a later call retries instead of serving a cached
+    // rejection (otherwise one failed batch poisons every commit in it).
+    promise.catch(() => commitInfoCache.delete(commit));
+    commitInfoCache.set(commit, promise);
+    return promise;
+}
 const changelogFunctions = {
     getDependencyReleaseLine: async (_changesets, dependenciesUpdated, options) => {
         if (!options.repo) {
@@ -24,24 +261,26 @@ const changelogFunctions = {
         }
         const replacedChangelog = changeset.summary.trim();
         const [firstLine, ...futureLines] = replacedChangelog.split('\n').map(l => l.trimEnd());
-        const links = await (async () => {
+        const info = await (async () => {
             const commitToFetchFrom = changeset.commit;
             if (commitToFetchFrom) {
-                const { links } = await (0, get_github_info_1.getInfo)({
-                    repo: options.repo,
-                    commit: commitToFetchFrom,
-                });
-                return links;
+                try {
+                    return await loadCommitInfo(options.repo, commitToFetchFrom);
+                }
+                catch (error) {
+                    process.stderr.write(`\n⚠️ Changelog: could not resolve GitHub info for changeset "${firstLine}" (commit ${commitToFetchFrom}): ${error instanceof Error ? error.message : String(error)}\n`);
+                }
             }
-            return {
-                commit: null,
-                pull: null,
-                user: null,
-            };
+            return EMPTY_COMMIT_INFO;
         })();
+        const { links, coAuthors } = info;
         const users = links.user;
         const pullOrCommit = links.pull || links.commit || null;
-        const userString = users !== null ? `by ${users}` : '';
+        const allUsersList = [users, ...coAuthors].filter(Boolean);
+        const allUsers = allUsersList.length > 1
+            ? `${allUsersList.slice(0, -1).join(', ')} and ${allUsersList[allUsersList.length - 1]}`
+            : allUsersList.join('');
+        const userString = allUsers ? `by ${allUsers}` : '';
         const pullString = pullOrCommit !== null ? `with ${pullOrCommit}` : '';
         const hasUserOrPull = userString && pullString;
         const entry = [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swisspost/design-system-changelog-github",
-  "version": "10.0.0-next.72",
+  "version": "10.0.0-next.76",
   "description": "A changelog entry generator for GitHub that links to PRs and users",
   "author": "Swiss Post <design-system@post.ch>",
   "license": "Apache-2.0",
@@ -18,8 +18,8 @@
   },
   "main": "./dist/index.js",
   "dependencies": {
-    "@changesets/get-github-info": "0.6.0",
-    "@changesets/types": "6.0.0",
+    "@changesets/get-github-info": "0.8.0",
+    "@changesets/types": "6.1.0",
     "dotenv": "17.2.3"
   },
   "devDependencies": {
@@ -27,9 +27,9 @@
     "@eslint/js": "9.18.0",
     "eslint": "9.26.0",
     "globals": "17.3.0",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.59.2",
-    "rimraf": "6.0.1"
+    "rimraf": "6.0.1",
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.62.0"
   },
   "keywords": [
     "changelog",