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

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @swisspost/design-system-changelog-github
 
+## 10.0.0
+
+### 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.76
+
 ## 10.0.0-next.75
 
 ### Minor Changes

package/dist/index.js

@@ -5,105 +5,243 @@
  */
 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;
 /**
- * Simple concurrency limiter to avoid overwhelming the GitHub API.
- * Limits parallel requests and adds a small delay between them.
+ * 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 createRateLimiter(concurrency, delayMs) {
-    let active = 0;
-    const queue = [];
-    function next() {
-        if (queue.length > 0 && active < concurrency) {
-            active++;
-            const resolve = queue.shift();
-            resolve();
+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));
         }
-    }
-    return async function (fn) {
-        await new Promise(resolve => {
-            queue.push(resolve);
-            next();
-        });
+        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 {
-            const result = await fn();
-            return result;
+            // 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 {
-            active--;
-            // Small delay between requests to avoid hitting secondary rate limits
-            await new Promise(resolve => setTimeout(resolve, delayMs));
-            next();
+            clearTimeout(timeout);
         }
-    };
+    }
 }
-// Cache GitHub info lookups by commit hash to avoid duplicate API calls
-const commitInfoCache = new Map();
-// Cache co-authors by commit hash
-const coAuthorsCache = new Map();
-// Allow max 5 concurrent requests with 100ms delay between them
-const rateLimited = createRateLimiter(5, 100);
-// Progress tracking
-let processedCount = 0;
-let cacheHits = 0;
-async function getGitHubInfo(repo, commit) {
-    if (commitInfoCache.has(commit)) {
-        cacheHits++;
-        processedCount++;
-        process.stderr.write(`\r🔗 Changelog: ${processedCount} processed (${cacheHits} cached)`);
-        return commitInfoCache.get(commit);
+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 promise = rateLimited(() => (0, get_github_info_1.getInfo)({ repo, commit }));
-    commitInfoCache.set(commit, promise);
-    processedCount++;
-    process.stderr.write(`\r🔗 Changelog: ${processedCount} processed (${cacheHits} cached)`);
-    return promise;
+  }`;
+    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}`;
 }
-/**
- * Fetch co-authors from the squash merge commit's Co-authored-by trailers.
- * With squash merging, the merge commit contains all co-author information.
- */
-async function getCoAuthors(repo, commit, mainUser) {
-    if (coAuthorsCache.has(commit)) {
-        return coAuthorsCache.get(commit);
+/** 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]);
+        }
     }
-    const promise = rateLimited(async () => {
-        const token = process.env.GITHUB_TOKEN;
-        if (!token)
-            return [];
-        const serverUrl = process.env.GITHUB_SERVER_URL || 'https://github.com';
-        const apiUrl = process.env.GITHUB_API_URL || 'https://api.github.com';
-        const response = await fetch(`${apiUrl}/repos/${repo}/commits/${commit}`, {
-            headers: {
-                Authorization: `Token ${token}`,
-                Accept: 'application/vnd.github.v3+json',
-            },
-        });
-        if (!response.ok)
-            return [];
-        const commitData = (await response.json());
-        const users = new Set();
-        // Parse Co-authored-by trailers from the squash merge commit
-        const coAuthorMatches = commitData.commit.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);
         }
-        // Remove the main PR author and bots
-        if (mainUser)
-            users.delete(mainUser);
-        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);
         }
-        return [...users].map(login => `[@${login}](${serverUrl}/${login})`);
+    }
+}
+/**
+ * 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();
     });
-    coAuthorsCache.set(commit, promise);
+    // 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 = {
@@ -123,25 +261,20 @@ 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 getGitHubInfo(options.repo, 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;
-        // Fetch co-authors from the squash merge commit
-        let coAuthors = [];
-        if (changeset.commit) {
-            const mainUser = links.user ? (links.user.match(/@([\w-]+)/)?.[1] ?? null) : null;
-            coAuthors = await getCoAuthors(options.repo, changeset.commit, mainUser);
-        }
         const pullOrCommit = links.pull || links.commit || null;
         const allUsersList = [users, ...coAuthors].filter(Boolean);
         const allUsers = allUsersList.length > 1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@swisspost/design-system-changelog-github",
-  "version": "10.0.0-next.75",
+  "version": "10.0.0",
   "description": "A changelog entry generator for GitHub that links to PRs and users",
   "author": "Swiss Post <design-system@post.ch>",
   "license": "Apache-2.0",
@@ -28,8 +28,8 @@
     "eslint": "9.26.0",
     "globals": "17.3.0",
     "rimraf": "6.0.1",
-    "typescript": "5.9.3",
-    "typescript-eslint": "8.59.2"
+    "typescript": "6.0.3",
+    "typescript-eslint": "8.62.0"
   },
   "keywords": [
     "changelog",