buddy-workbench 0.2.9 → 0.2.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buddy-workbench",
-  "version": "0.2.9",
+  "version": "0.2.10",
   "private": false,
   "type": "module",
   "bin": {

package/server/routes/jira-filters.js

@@ -354,24 +354,49 @@ async function searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates
 }
 
 async function fetchCommentsForIssue(jiraHost, headers, issueKey, maxResults = 50) {
-  try {
-    const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
-    const response = await httpClient.get(url, { headers });
-    if (response.status !== 200) return [];
-    const total = response.data?.total || 0;
-    const comments = Array.isArray(response.data?.comments) ? response.data.comments : [];
-    if (total > comments.length && total > maxResults) {
-      const startAt = Math.max(0, total - maxResults);
-      const latestUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?startAt=${startAt}&maxResults=${maxResults}`;
-      const latestResponse = await httpClient.get(latestUrl, { headers });
-      if (latestResponse.status === 200 && Array.isArray(latestResponse.data?.comments)) {
-        return latestResponse.data.comments;
+  const requestComments = async (url) => {
+    const maxRetries = 4;
+    for (let attempt = 0; ; attempt += 1) {
+      const response = await httpClient.get(url, { headers });
+      if (response.status === 200 && Array.isArray(response.data?.comments)) return response;
+      if (response.status !== 429 || attempt >= maxRetries) {
+        const error = new Error(`Jira comments request for ${issueKey} returned HTTP ${response.status}`);
+        error.status = response.status;
+        throw error;
       }
+
+      const retryAfter = response.headers?.['retry-after'] ?? response.headers?.['Retry-After'];
+      const retryAfterSeconds = Number(retryAfter);
+      const retryAfterDate = Date.parse(retryAfter);
+      const delayMs = Number.isFinite(retryAfterSeconds) && retryAfterSeconds >= 0
+        ? retryAfterSeconds * 1000
+        : Number.isFinite(retryAfterDate)
+          ? Math.max(0, retryAfterDate - Date.now())
+          : Math.min(1000 * (2 ** attempt), 10000);
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
     }
-    return comments;
-  } catch {
-    return [];
+  };
+
+  const url = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?maxResults=${maxResults}`;
+  const response = await requestComments(url);
+  const total = response.data?.total || 0;
+  const comments = response.data.comments;
+  if (total > comments.length && total > maxResults) {
+    const startAt = Math.max(0, total - maxResults);
+    const latestUrl = `https://${jiraHost}/rest/api/2/issue/${encodeURIComponent(issueKey)}/comment?startAt=${startAt}&maxResults=${maxResults}`;
+    const latestResponse = await requestComments(latestUrl);
+    return latestResponse.data.comments;
+  }
+  return comments;
+}
+
+async function mapInBatches(items, batchSize, mapper) {
+  const results = [];
+  for (let index = 0; index < items.length; index += batchSize) {
+    const batchResults = await Promise.all(items.slice(index, index + batchSize).map(mapper));
+    results.push(...batchResults);
   }
+  return results;
 }
 
 router.get('/recently-created', (_req, res) => {
@@ -409,7 +434,7 @@ router.get('/recently-commented', async (_req, res) => {
     const issues = await searchJiraWithFallbacksPaginated(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter');
     const results = [];
 
-    const issueCommentsPromises = issues.map(async (issue) => {
+    const issueComments = await mapInBatches(issues, 5, async (issue) => {
       const key = issue.key;
       const fields = issue.fields || {};
       const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
@@ -436,8 +461,7 @@ router.get('/recently-commented', async (_req, res) => {
       return null;
     });
 
-    const settled = await Promise.all(issueCommentsPromises);
-    for (const item of settled) {
+    for (const item of issueComments) {
       if (item) results.push(item);
     }
 
@@ -478,7 +502,7 @@ router.get('/recently-mentioned', async (_req, res) => {
     const issues = await searchJiraWithFallbacks(jiraHost, headers, jqlCandidates, 'summary,priority,status,updated,assignee,reporter', 40);
     const results = [];
 
-    const issueMentionsPromises = issues.slice(0, 30).map(async (issue) => {
+    const issueMentions = await mapInBatches(issues.slice(0, 30), 5, async (issue) => {
       const key = issue.key;
       const fields = issue.fields || {};
       const comments = await fetchCommentsForIssue(jiraHost, headers, key, 50);
@@ -511,8 +535,7 @@ router.get('/recently-mentioned', async (_req, res) => {
       return null;
     });
 
-    const settled = await Promise.all(issueMentionsPromises);
-    for (const item of settled) {
+    for (const item of issueMentions) {
       if (item) results.push(item);
     }
 

package/server/routes/package-upgrade.js

@@ -12,6 +12,7 @@ import { recordApiError } from '../lib/api-errors.js';
 const router = Router();
 const exec = promisify(execFile);
 const running = new Set();
+const BITBUCKET_REQUEST_BATCH_SIZE = 5;
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 const httpClient = axios.create({
   httpsAgent,
@@ -239,14 +240,24 @@ router.post('/repos/branches', async (req, res) => {
   const repos = repoIds.map((repoId) => data.repos.find((repo) => repo.id === repoId)).filter(Boolean);
   if (!repos.length) return res.json([]);
   try {
-    const remote = await Promise.all(repos.map((repo) => fetchRemoteBranches(repo)));
+    const remote = [];
+    for (let index = 0; index < repos.length; index += BITBUCKET_REQUEST_BATCH_SIZE) {
+      remote.push(...await Promise.all(repos.slice(index, index + BITBUCKET_REQUEST_BATCH_SIZE).map(fetchRemoteBranches)));
+    }
     const branchSets = remote.map(({ branches }) => new Set(branches.map((branch) => branch.name)));
     const commonNames = remote[0].branches.map((branch) => branch.name).filter((name) => branchSets.every((branches) => branches.has(name)));
-    const commonBranches = await Promise.all(commonNames.map(async (name) => {
-      const branches = remote.map(({ base, branches: items }) => ({ base, branch: items.find((item) => item.name === name) })).filter(({ branch }) => branch);
-      const updated = await Promise.all(branches.map(({ base, branch }) => fetchBranchUpdatedAt(base, branch)));
-      return { name, updatedAt: Math.max(...updated.map((item) => item.updatedAt)), rank: Math.min(...updated.map((item) => item.rank)) };
-    }));
+    const commonBranches = [];
+    for (let index = 0; index < commonNames.length; index += BITBUCKET_REQUEST_BATCH_SIZE) {
+      const batch = await Promise.all(commonNames.slice(index, index + BITBUCKET_REQUEST_BATCH_SIZE).map(async (name) => {
+        const branches = remote.map(({ base, branches: items }) => ({ base, branch: items.find((item) => item.name === name) })).filter(({ branch }) => branch);
+        const updated = [];
+        for (let branchIndex = 0; branchIndex < branches.length; branchIndex += BITBUCKET_REQUEST_BATCH_SIZE) {
+          updated.push(...await Promise.all(branches.slice(branchIndex, branchIndex + BITBUCKET_REQUEST_BATCH_SIZE).map(({ base, branch }) => fetchBranchUpdatedAt(base, branch))));
+        }
+        return { name, updatedAt: Math.max(...updated.map((item) => item.updatedAt)), rank: Math.min(...updated.map((item) => item.rank)) };
+      }));
+      commonBranches.push(...batch);
+    }
     commonBranches.sort((a, b) => b.updatedAt - a.updatedAt || a.rank - b.rank || a.name.localeCompare(b.name));
     res.json(commonBranches.map(({ name, updatedAt }) => ({ name, updatedAt: updatedAt ? new Date(updatedAt).toISOString() : null })));
   } catch (error) {

package/server/routes/pr-conflicts.js

@@ -10,6 +10,7 @@ import { readPackageUpgradeData } from '../repositories/package-upgrade.js';
 import { getGitRemoteUrl } from '../services/git.js';
 
 const router = Router();
+const CONFLICT_CHECK_BATCH_SIZE = 5;
 const execFileAsync = promisify(execFile);
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 const client = axios.create({ httpsAgent, validateStatus: () => true });
@@ -335,35 +336,39 @@ router.get('/my-conflicts', async (_req, res) => {
       }
     });
 
-    const conflicts = await Promise.all(values.map(async (pr) => {
-      const project = pr.toRef?.repository?.project?.key;
-      const repository = pr.toRef?.repository?.slug;
-      if (!project || !repository || !pr.id) return null;
-      if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
-
-      const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
-      const baseConflict = {
-        id: pr.id,
-        title: pr.title || `Pull Request #${pr.id}`,
-        repositoryName: pr.toRef?.repository?.name || repository,
-        sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
-        targetBranch: pr.toRef?.displayId || pr.toRef?.id,
-        updatedDate: pr.updatedDate,
-        url: webPullRequestUrl(host, pr)
-      };
-      if (resolutionPr) {
-        return {
-          ...baseConflict,
-          resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
-          resolutionPrId: resolutionPr.id
+    const conflicts = [];
+    for (let index = 0; index < values.length; index += CONFLICT_CHECK_BATCH_SIZE) {
+      const batch = await Promise.all(values.slice(index, index + CONFLICT_CHECK_BATCH_SIZE).map(async (pr) => {
+        const project = pr.toRef?.repository?.project?.key;
+        const repository = pr.toRef?.repository?.slug;
+        if (!project || !repository || !pr.id) return null;
+        if (String(pr.description || '').match(/This branch resolves conflicts for Pull Request #\d+/i)) return null;
+
+        const resolutionPr = resolutionPrs.get(pullRequestKey(project, repository, pr.id));
+        const baseConflict = {
+          id: pr.id,
+          title: pr.title || `Pull Request #${pr.id}`,
+          repositoryName: pr.toRef?.repository?.name || repository,
+          sourceBranch: pr.fromRef?.displayId || pr.fromRef?.id,
+          targetBranch: pr.toRef?.displayId || pr.toRef?.id,
+          updatedDate: pr.updatedDate,
+          url: webPullRequestUrl(host, pr)
         };
-      }
+        if (resolutionPr) {
+          return {
+            ...baseConflict,
+            resolutionPrUrl: webPullRequestUrl(host, resolutionPr),
+            resolutionPrId: resolutionPr.id
+          };
+        }
 
-      const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
-      const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
-      if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
-      return baseConflict;
-    }));
+        const mergeUrl = `https://${host}/rest/api/latest/projects/${encodeURIComponent(project)}/repos/${encodeURIComponent(repository)}/pull-requests/${pr.id}/merge`;
+        const mergeResponse = await client.get(mergeUrl, { headers: authHeaders() });
+        if (mergeResponse.status < 200 || mergeResponse.status >= 300 || !mergeResponse.data?.conflicted) return null;
+        return baseConflict;
+      }));
+      conflicts.push(...batch);
+    }
     const sorted = conflicts.filter(Boolean).sort((a, b) => (b.updatedDate || 0) - (a.updatedDate || 0));
     const unresolved = sorted.filter((pr) => !pr.resolutionPrUrl);
     const resolved = sorted.filter((pr) => pr.resolutionPrUrl);